This is the base Capability Statement for FHIR. It represents a server that provides the full set of functionality defined by FHIR. It is provided to use as a template for system designers to build their own Capability Statements from
\n| Mode | SERVER |
| Description | All the functionality defined in FHIR |
| Transaction | y |
| System History | y |
| System Search | y |
This is the base Capability Statement for FHIR. It represents a server that provides the none of the functionality defined by FHIR. It is provided to use as a template for system designers to build their own Capability Statements from. A capability statement has to contain something, so this contains a read of a Capability Statement
\n| Mode | SERVER |
| Description | An empty Capability Statement |
| Transaction | |
| System History | |
| System Search |
| Resource Type | Profile | Read | V-Read | Search | Update | Updates | Create | Delete | History |
|---|---|---|---|---|---|---|---|---|---|
| CapabilityStatement | y |
\r\nThe following resources may be in this compartment:\r\n
\r\n| Resource | Inclusion Criteria |
| Account | subject |
| Appointment | actor |
| AppointmentResponse | actor |
| AuditEvent | agent |
| ChargeItem | enterer, participant-actor |
| Communication | sender, recipient |
| CommunicationRequest | sender, recipient |
| Composition | author |
| DetectedIssue | author |
| Device | {def} |
| DeviceComponent | source |
| DeviceMetric | source |
| DeviceRequest | device, subject, requester, performer |
| DeviceUseStatement | device |
| DiagnosticReport | subject |
| DocumentManifest | subject, author |
| DocumentReference | subject, author |
| Flag | author |
| Group | member |
| ImagingManifest | author |
| List | subject, source |
| Media | subject |
| MedicationAdministration | device |
| MessageHeader | target |
| Observation | subject, device |
| ProcedureRequest | performer, requester |
| Provenance | agent |
| QuestionnaireResponse | author |
| RequestGroup | author |
| RiskAssessment | performer |
| Schedule | actor |
| Specimen | subject |
| SupplyRequest | requester |
\r\nA resource is in this compartment if the nominated search parameter (or chain) refers to the patient resource that defines the compartment.\r\n
\r\n\r\n\r\n
\r\n\r\nThe following resources are never in this compartment:\r\n
\r\n\r\nThe following resources may be in this compartment:\r\n
\r\n| Resource | Inclusion Criteria |
| ChargeItem | context |
| Claim | encounter |
| ClinicalImpression | context |
| Communication | context |
| CommunicationRequest | context |
| Composition | encounter |
| Condition | context |
| DeviceRequest | encounter |
| DiagnosticReport | encounter |
| DocumentReference | encounter |
| Encounter | {def} |
| ExplanationOfBenefit | encounter |
| MedicationAdministration | context |
| MedicationRequest | context |
| NutritionOrder | encounter |
| Observation | encounter |
| Procedure | encounter |
| ProcedureRequest | context |
| QuestionnaireResponse | context |
| RequestGroup | encounter |
| VisionPrescription | encounter |
\r\nA resource is in this compartment if the nominated search parameter (or chain) refers to the patient resource that defines the compartment.\r\n
\r\n\r\n\r\n
\r\n\r\nThe following resources are never in this compartment:\r\n
\r\n\r\nThe following resources may be in this compartment:\r\n
\r\n| Resource | Inclusion Criteria |
| Account | subject |
| AdverseEvent | subject |
| AllergyIntolerance | patient, recorder, asserter |
| Appointment | actor |
| AppointmentResponse | actor |
| AuditEvent | patient, agent.patient, entity.patient |
| Basic | patient, author |
| BodySite | patient |
| CarePlan | patient, performer |
| CareTeam | patient, participant |
| ChargeItem | subject |
| Claim | patient, payee |
| ClaimResponse | patient |
| ClinicalImpression | subject |
| Communication | subject, sender, recipient |
| CommunicationRequest | subject, sender, recipient, requester |
| Composition | subject, author, attester |
| Condition | patient, asserter |
| Consent | patient |
| Coverage | policy-holder, subscriber, beneficiary, payor |
| DetectedIssue | patient |
| DeviceRequest | subject, requester, performer |
| DeviceUseStatement | subject |
| DiagnosticReport | subject |
| DocumentManifest | subject, author, recipient |
| DocumentReference | subject, author |
| EligibilityRequest | patient |
| Encounter | patient |
| EnrollmentRequest | subject |
| EpisodeOfCare | patient |
| ExplanationOfBenefit | patient, payee |
| FamilyMemberHistory | patient |
| Flag | patient |
| Goal | patient |
| Group | member |
| ImagingManifest | patient, author |
| ImagingStudy | patient |
| Immunization | patient |
| ImmunizationRecommendation | patient |
| List | subject, source |
| MeasureReport | patient |
| Media | subject |
| MedicationAdministration | patient, performer, subject |
| MedicationDispense | subject, patient, receiver |
| MedicationRequest | subject |
| MedicationStatement | subject |
| NutritionOrder | patient |
| Observation | subject, performer |
| Patient | link |
| Person | patient |
| Procedure | patient, performer |
| ProcedureRequest | subject, performer |
| Provenance | target.subject, target.patient, patient |
| QuestionnaireResponse | subject, author |
| ReferralRequest | patient, requester |
| RelatedPerson | patient |
| RequestGroup | subject, participant |
| ResearchSubject | individual |
| RiskAssessment | subject |
| Schedule | actor |
| Specimen | subject |
| SupplyDelivery | patient |
| SupplyRequest | requester |
| VisionPrescription | patient |
\r\nA resource is in this compartment if the nominated search parameter (or chain) refers to the patient resource that defines the compartment.\r\n
\r\n\r\n\r\n
\r\n\r\nThe following resources are never in this compartment:\r\n
\r\n\r\nThe following resources may be in this compartment:\r\n
\r\n| Resource | Inclusion Criteria |
| Account | subject |
| AdverseEvent | recorder |
| AllergyIntolerance | recorder, asserter |
| Appointment | actor |
| AppointmentResponse | actor |
| AuditEvent | agent |
| Basic | author |
| CarePlan | performer |
| CareTeam | participant |
| ChargeItem | enterer, participant-actor |
| Claim | enterer, provider, payee, care-team |
| ClaimResponse | request-provider |
| ClinicalImpression | assessor |
| Communication | sender, recipient |
| CommunicationRequest | sender, recipient, requester |
| Composition | subject, author, attester |
| Condition | asserter |
| DetectedIssue | author |
| DeviceRequest | requester, performer |
| DiagnosticReport | performer |
| DocumentManifest | subject, author, recipient |
| DocumentReference | subject, author, authenticator |
| EligibilityRequest | enterer, provider |
| EligibilityResponse | request-provider |
| Encounter | practitioner, participant |
| EpisodeOfCare | care-manager |
| ExplanationOfBenefit | enterer, provider, payee, care-team |
| Flag | author |
| Group | member |
| ImagingManifest | author |
| Immunization | practitioner |
| Linkage | author |
| List | source |
| Media | subject, operator |
| MedicationAdministration | performer |
| MedicationDispense | performer, receiver |
| MedicationRequest | requester |
| MedicationStatement | source |
| MessageHeader | receiver, author, responsible, enterer |
| NutritionOrder | provider |
| Observation | performer |
| Patient | general-practitioner |
| PaymentNotice | provider |
| PaymentReconciliation | request-provider |
| Person | practitioner |
| Practitioner | {def} |
| PractitionerRole | practitioner |
| Procedure | performer |
| ProcedureRequest | performer, requester |
| ProcessRequest | provider |
| ProcessResponse | request-provider |
| Provenance | agent |
| QuestionnaireResponse | author, source |
| ReferralRequest | requester, recipient |
| RequestGroup | participant, author |
| ResearchStudy | principalinvestigator |
| RiskAssessment | performer |
| Schedule | actor |
| Specimen | collector |
| SupplyDelivery | supplier, receiver |
| SupplyRequest | requester |
| VisionPrescription | prescriber |
\r\nA resource is in this compartment if the nominated search parameter (or chain) refers to the patient resource that defines the compartment.\r\n
\r\n\r\n\r\n
\r\n\r\nThe following resources are never in this compartment:\r\n
\r\n\r\nThe following resources may be in this compartment:\r\n
\r\n| Resource | Inclusion Criteria |
| AdverseEvent | recorder |
| AllergyIntolerance | asserter |
| Appointment | actor |
| AppointmentResponse | actor |
| Basic | author |
| CarePlan | performer |
| CareTeam | participant |
| ChargeItem | enterer, participant-actor |
| Claim | payee |
| Communication | sender, recipient |
| CommunicationRequest | sender, recipient, requester |
| Composition | author |
| Condition | asserter |
| Coverage | policy-holder, subscriber, payor |
| DocumentManifest | author |
| DocumentReference | author |
| Encounter | participant |
| ExplanationOfBenefit | payee |
| ImagingManifest | author |
| MedicationAdministration | performer |
| MedicationStatement | source |
| Observation | performer |
| Patient | link |
| Person | link |
| Procedure | performer |
| ProcedureRequest | performer |
| Provenance | agent |
| QuestionnaireResponse | author, source |
| RelatedPerson | {def} |
| RequestGroup | participant |
| Schedule | actor |
| SupplyRequest | requester |
\r\nA resource is in this compartment if the nominated search parameter (or chain) refers to the patient resource that defines the compartment.\r\n
\r\n\r\n\r\n
\r\n\r\nThe following resources are never in this compartment:\r\n
\r\nOPERATION: Apply
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/ActivityDefinition-apply
The apply operation realizes a definition in a specific context
\nURL: [base]/ActivityDefinition/[id]/$apply
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | patient | 1..1 | Reference | The patient that is the target of the activity to be applied \n | |
| IN | encounter | 0..1 | Reference | The encounter in context, if any \n | |
| IN | practitioner | 0..1 | Reference | The practitioner in context \n | |
| IN | organization | 0..1 | Reference | The organization in context \n | |
| IN | userType | 0..1 | CodeableConcept | The type of user initiating the request, e.g. patient, healthcare provider, or specific type of healthcare provider (physician, nurse, etc.) \n | |
| IN | userLanguage | 0..1 | CodeableConcept | Preferred language of the person using the system \n | |
| IN | userTaskContext | 0..1 | CodeableConcept | The task the system user is performing, e.g. laboratory results review, medication list review, etc. This information can be used to tailor decision support outputs, such as recommended information resources \n | |
| IN | setting | 0..1 | CodeableConcept | The current setting of the request (inpatient, outpatient, etc) \n | |
| IN | settingContext | 0..1 | CodeableConcept | Additional detail about the setting of the request, if any \n | |
| OUT | return | 1..1 | Any | The resource that is the result of applying the definition \n |
The result of invoking this operation is a resource of the type specified by the activity definition, with all the definitions resolved as appropriate for the type of resource. Any dynamicValue elements will be evaluated and the resulting value used for the values of the appropriate elements of the returned resource. If the ActivityDefinition includes library references, those libraries will be available to the evaluated expressions. If those libraries have parameters, those parameters will be bound by name to the parameters given to the operation
\nOPERATION: Data Requirements
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/ActivityDefinition-data-requirements
The data-requirements operation aggregates and returns the parameters and data requirements for the activity definition and all its dependencies as a single module definition library
\nURL: [base]/ActivityDefinition/[id]/$data-requirements
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| OUT | return | 1..1 | Library | The result of the requirements gathering represented as a module-definition Library that describes the aggregate parameters, data requirements, and dependencies of the activity definition \n |
The effect of invoking this operation is to determine the aggregate set of data requirements and dependencies for the activity definition. The result is a Library resource with a type of module-definition that contains all the parameter definitions and data requirements of the activity definition and any libraries referenced by it. Implementations SHOULD aggregate data requirements intelligently (i.e. by collapsing overlapping data requirements)
\nOPERATION: Test if a server implements a client's required operations
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/CapabilityStatement-conforms
This operation asks the server to check that it implements all the resources, interactions, search parameters, and operations that the client provides in its capability statement. The client provides both capability statements by reference, and must ensure that all the referenced resources are available to the conformance server
\nURL: [base]/CapabilityStatement/$conforms
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | left | 0..1 | uri | The canonical URL for the left-hand system's capability statement \n | |
| IN | right | 0..1 | uri | The canonical URL for the right-hand system's capability statement \n | |
| IN | mode | 0..1 | code | What kind of comparison to perform - server to server, or client to server (use the codes 'server/server' or 'client/server') \n | |
| OUT | issues | 1..1 | OperationOutcome | Outcome of the CapabilityStatement test \n | |
| OUT | union | 0..1 | CapabilityStatement | The intersection of the functionality described by the CapabilityStatement resources \n | |
| OUT | intersection | 0..1 | CapabilityStatement | The union of the functionality described by the CapabilityStatement resources \n |
The operation performs a full comparison of the functionality described by the two capability statements, including the profiles and value sets they reference, and also including concept maps and structure maps.
\nThe full execution of this operation is still a matter of research, but it is intended to support comparison of systems to see if they will interoperate
\nIf the capability statements can be successfully compared, then the return value is a 200 OK with an OperationOutcome along with intersection and union capability statements. The operation outcome can contain errors relating to differences between the capability statements. If the capability statements cannot be compared, because dependencies cannot be located, the return value is a 4xx error, with an OperationOutcome with at least one issue with severity >= error
\nOPERATION: Test if a server implements a client's required operations
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/CapabilityStatement-implements
This operation asks the server to check that it implements all the resources, interactions, search parameters, and operations that the client provides in its capability statement. The client provides its capability statement inline, or by referring the server to the canonical URL of its capability statement
\nURL: [base]/CapabilityStatement/$implements
URL: [base]/CapabilityStatement/[id]/$implements
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | server | 0..1 | uri | The canonical URL for the server capability statement - use this if the implements is not invoked on an instance (or on the /metadata end-point) \n | |
| IN | client | 0..1 | uri | The canonical URL for the client capability statement - use this if the implements is not invoked on an instance (or on the /metadata end-point) \n | |
| IN | resource | 0..1 | CapabilityStatement | The client capability statement, provided inline \n | |
| OUT | return | 1..1 | OperationOutcome | Outcome of the CapabilityStatement test \n |
The operation does not perform a full conformance check; in particular it does not check that the profiles align. It merely checks that the behaviors the client wishes to use are provided
\nTechnically, this operation is implemented as follows:\n* The server's capability statement must have an entry for each resource in the client's capability statement\n* The servers' resource support must have matching flags for updateCreate, conditionalCreate, conditionalRead, conditionalUpdate, conditionalDelete, searchInclude, searchRevInclude\n* The server capability statement must have a matching interaction for each interaction in the client capability statement (whether or not it is on a resource)\n* The server must have a search parameter with matching name and definition for any search parameters in the client capability statement\n* The server must have an operation definitions with a matching reference for any operations in the client capability statement
\nIf the capability statements match by these rules, then the return value is a 200 OK with an operation outcome that contains no issues with severity >= error. If the capability statement doesn't match, the return value is a 4xx error, with an OperationOutcome with at least one issue with severity >= error
\nOPERATION: Fetch a subset of the CapabilityStatement resource
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/CapabilityStatement-subset
This operation asks the server to return a subset of the CapabilityStatement resource - just the REST parts that relate to a set of nominated resources - the resources that the client is interested in
\nURL: [base]/CapabilityStatement/$subset
URL: [base]/CapabilityStatement/[id]/$subset
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | server | 0..1 | uri | The canonical URL - use this if the subset is not invoked on an instance (or on the /metadata end-point) \n | |
| IN | resource | 1..* | code | A resource that the client would like to include in the return \n | |
| OUT | return | 1..1 | CapabilityStatement | The subsetted CapabilityStatement resource that is returned. This should be tagged with the SUBSETTED code \n |
OPERATION: Code Composition based on supplied properties
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/CodeSystem-compose
Given a set of properties, return one or more possible matching codes
\nThis operation takes a set of properties, and examines the code system looking for codes in the code system that match a set of known properties.
\nWhen looking for matches, there are 3 possible types of match:\n* a complete match - a code that represents all the provided properties correctly\n* a partial match - a code that represents some of the provided properties correctly, and not others\n* a possible match - a code that may represent the provided properties closely, but may capture less or more precise informationfor some of the properties
\nThe $compose operation can be called in one of 2 modes:\n* By a human, looking for the best match for a set of properties. In this mode, the server returns a list of complete, possible or partial matches (possibly with comments), so that the user can choose (or not) the most appropriate code\n* By a machine (typically in a system interface performing a transformation). In this mode, the server returns only a list of complete and partial matches, but no possible matches. The machine can choose a code from the list (or not) based on what properties are not coded
\nThese modes are differentiated by the 'exact' parameter, so the client can indicate whether it only wants exact matches (including partial matches) or whether potential matches based on text matching are desired
\nThe compose operation is still preliminary. The interface can be expected to change as more experience is gained from implementations.
\nURL: [base]/CodeSystem/$compose
URL: [base]/CodeSystem/[id]/$compose
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | system | 0..1 | uri | The system in which composition is to be performed. This must be provided unless the operation is invoked on a code system instance \n | |
| IN | version | 0..1 | string | The version of the system for the inferencing to be performed \n | |
| IN | property | 0..* | One or more properties that contain information to be composed into the code \n | ||
| IN | property.code | 1..1 | code | Identifies the property provided \n | |
| IN | property.value | 0..1 | code | The value of the property provided \n | |
| IN | property.subproperty | 0..* | Nested Properties (mainly used for SNOMED CT composition, for relationship Groups) \n | ||
| IN | property.subproperty.code | 1..1 | code | Identifies the sub-property provided \n | |
| IN | property.subproperty.value | 1..1 | code | The value of the sub-property provided \n | |
| IN | exact | 1..1 | boolean | Whether the operation is being used by a human, or a machine. If the operation is being used by a human, the terminology server can return a list of possible matches, with commentary. For a machine, the server returns sure matches, or none at all \n | |
| IN | compositional | 0..1 | boolean | Post-coordinated expressions are allowed to be returned in the matching codes (mainly for SNOMED CT). Default = false \n | |
| OUT | match | 0..* | Concepts returned by the server as a result of the inferencing operation \n | ||
| OUT | match.code | 1..1 | Coding | A code that matches the properties provided \n | |
| OUT | match.unmatched | 0..* | One or more properties that contain properties that could not be matched into the code \n | ||
| OUT | match.unmatched.code | 1..1 | code | Identifies the property provided \n | |
| OUT | match.unmatched.value | 1..1 | code | The value of the property provided \n | |
| OUT | match.unmatched.property | 0..* | Nested Properties (mainly used for SNOMED CT composition, for relationship Groups) \n | ||
| OUT | match.unmatched.property.code | 1..1 | code | Identifies the sub-property provided \n | |
| OUT | match.unmatched.property.value | 1..1 | code | The value of the sub-property provided \n | |
| OUT | match.comment | 0..1 | string | Information about the quality of the match, if operation is for a human \n |
OPERATION: Concept Look Up & Decomposition
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/CodeSystem-lookup
Given a code/system, or a Coding, get additional details about the concept, including definition, status, designations, and properties. One of the products of this operation is a full decomposition of a code from a structure terminology
\nURL: [base]/CodeSystem/$lookup
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | code | 0..1 | code | The code that is to be located. If a code is provided, a system must be provided \n | |
| IN | system | 0..1 | uri | The system for the code that is to be located \n | |
| IN | version | 0..1 | string | The version of the system, if one was provided in the source data \n | |
| IN | coding | 0..1 | Coding | A coding to look up \n | |
| IN | date | 0..1 | dateTime | The date for which the information should be returned. Normally, this is the current conditions (which is the default value) but under some circumstances, systems need to acccess this information as it would have been in the past. A typical example of this would be where code selection is constrained to the set of codes that were available when the patient was treated, not when the record is being edited. Note that which date is appropriate is a matter for implementation policy. \n | |
| IN | displayLanguage | 0..1 | code | The requested language for display (see ExpansionProfile.displayLanguage) \n | |
| IN | property | 0..* | code | A property that the client wishes to be returned in the output. If no properties are specified, the server chooses what to return. The following properties are defined for all code systems: url, name, version (code system info) and code information: display, definition, designation, parent and child, and for designations, lang.X where X is a designation language code. Some of the properties are returned explicit in named parameters (when the names match), and the rest (except for lang.X) in the property parameter group \n | |
| OUT | name | 1..1 | string | A display name for the code system \n | |
| OUT | version | 0..1 | string | The version that these details are based on \n | |
| OUT | display | 1..1 | string | The preferred display for this concept \n | |
| OUT | designation | 0..* | Additional representations for this concept \n | ||
| OUT | designation.language | 0..1 | code | The language this designation is defined for \n | |
| OUT | designation.use | 0..1 | Coding | A code that details how this designation would be used \n | |
| OUT | designation.value | 1..1 | string | The text value for this designation \n | |
| OUT | property | 0..* | One or more properties that contain additional information about the code, including status. For complex terminologies (e.g. SNOMED CT, LOINC, medications), these properties serve to decompose the code \n | ||
| OUT | property.code | 1..1 | code | Identifies the property returned \n | |
| OUT | property.value | 0..1 | code | The value of the property returned \n | |
| OUT | property.description | 0..1 | string | Human Readable representation of the property value (e.g. display for a code) \n | |
| OUT | property.subproperty | 0..* | Nested Properties (mainly used for SNOMED CT decomposition, for relationship Groups) \n | ||
| OUT | property.subproperty.code | 1..1 | code | Identifies the sub-property returned \n | |
| OUT | property.subproperty.value | 1..1 | code | The value of the sub-property returned \n | |
| OUT | property.subproperty.description | 0..1 | string | Human Readable representation of the property value (e.g. display for a code) \n |
Note that the $lookup operation is more than just a code system search - the server finds the concept, and gathers the return information from the underlying code system definitions.
\nOPERATION: Subsumption Testing
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/CodeSystem-subsumes
Test the subsumption relationship between code/Coding A and code/Coding B given the semantics of subsumption in the underlying code system (see hierarchyMeaning)
\nURL: [base]/CodeSystem/$subsumes
URL: [base]/CodeSystem/[id]/$subsumes
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | codeA | 0..1 | code | The "A" code that is to be tested. If a code is provided, a system must be provided \n | |
| IN | codeB | 0..1 | code | The "B" code that is to be tested. If a code is provided, a system must be provided \n | |
| IN | system | 0..1 | uri | The code system in which subsumption testing is to be performed. This must be provided unless the operation is invoked on a code system instance \n | |
| IN | version | 0..1 | string | The version of the code system, if one was provided in the source data \n | |
| IN | codingA | 0..1 | Coding | The "A" Coding that is to be tested. The code system does not have to match the specified subsumption code system, but the relationships between the code systems must be well established \n | |
| IN | codingB | 0..1 | Coding | The "B" Coding that is to be tested. The code system does not have to match the specified subsumption code system, but the relationships between the code systems must be well established \n | |
| OUT | outcome | 1..1 | code | The subsumption relationship between code/Coding "A" and code/Coding "B". There are 4 possible codes to be returned: equivalent, subsumes, subsumed-by, and not-subsumed. If the server is unable to determine the relationship between the codes/Codings, then it returns an error (i.e. an OperationOutcome) \n |
OPERATION: Generate a Document
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Composition-document
A client can ask a server to generate a fully bundled document from a composition resource. The server takes the composition resource, locates all the referenced resources and other additional resources as configured or requested and either returns a full document bundle, or returns an error. Note that since this is a search operation, the document bundle is wrapped inside the search bundle. If some of the resources are located on other servers, it is at the discretion of the server whether to retrieve them or return an error. If the correct version of the document that would be generated already exists, then the server can return the existing one.
\nURL: [base]/Composition/$document
URL: [base]/Composition/[id]/$document
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | persist | 0..1 | boolean | Whether to store the document at the bundle end-point (/Bundle) or not once it is generated. Value = true or false (default is for the server to decide). If the document is stored, it's location can be inferred from the Bundle.id, but it SHOULD be provided explicitly in the HTTP Location header in the response \n |
Note: this operation definition does not resolve the question how document signatures are created. This is an open issue during the period of trial use, and feedback is requested regarding this question
\nOPERATION: Closure Table Maintenance
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/ConceptMap-closure
This operation provides support for ongoing maintenance of a client-side transitive closure table based on server-side terminological logic. For details of how this is used, see Maintaining a Closure Table
\nURL: [base]/$closure
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | name | 1..1 | string | The name that defines the particular context for the subsumption based closure table \n | |
| IN | concept | 0..* | Coding | Concepts to add to the closure table \n | |
| IN | version | 0..1 | id | A request to resynchronise - request to send all new entries since the nominated version was sent by the server \n | |
| OUT | return | 1..1 | ConceptMap | A list of new entries (code / system --> code/system) that the client should add to its closure table. The only kind of entry mapping equivalences that can be returned are equal, specializes, subsumes and unmatched \n |
OPERATION: Concept Translation
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/ConceptMap-translate
Translate a code from one value set to another, based on the existing value set and concept maps resources, and/or other additional knowledge available to the server.
\nOne (and only one) of the in parameters (code, coding, codeableConcept) must be provided, to identify the code that is to be translated.
The operation returns a set of parameters including a 'result' for whether there is an acceptable match, and a list of possible matches. Note that the list of matches may include notes of codes for which mapping is specifically excluded, so implementers have to check the match.equivalence for each match
\nURL: [base]/ConceptMap/$translate
URL: [base]/ConceptMap/[id]/$translate
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | code | 0..1 | code | The code that is to be translated. If a code is provided, a system must be provided \n | |
| IN | system | 0..1 | uri | The system for the code that is to be translated \n | |
| IN | version | 0..1 | string | The version of the system, if one was provided in the source data \n | |
| IN | source | 0..1 | uri | Identifies the value set used when the concept (system/code pair) was chosen. May be a logical id, or an absolute or relative location. The source value set is an optional parameter because in some cases, the client cannot know what the source value set is. However, without a source value set, the server may be unable to safely identify an applicable concept map, and would return an error. For this reason, a source value set SHOULD always be provided. Note that servers may be able to identify an appropriate concept map without a source value set if there is a full mapping for the entire code system in the concept map, or by manual intervention \n | |
| IN | coding | 0..1 | Coding | A coding to translate \n | |
| IN | codeableConcept | 0..1 | CodeableConcept | A full codeableConcept to validate. The server can translate any of the coding values (e.g. existing translations) as it chooses \n | |
| IN | target | 0..1 | uri | Identifies the value set in which a translation is sought. May be a logical id, or an absolute or relative location. If there's no target specified, the server should return all known translations, along with their source \n | |
| IN | targetsystem | 0..1 | uri | identifies a target code system in which a mapping is sought. This parameter is an alternative to the target parameter - only one is required. Searching for any translation to a target code system irrespective of the context (e.g. target valueset) may lead to unsafe results, and it is at the discretion of the server to decide when to support this operation \n | |
| IN | dependency | 0..* | Another element that may help produce the correct mapping \n | ||
| IN | dependency.element | 0..1 | uri | The element for this dependency \n | |
| IN | dependency.concept | 0..1 | CodeableConcept | The value for this dependency \n | |
| IN | reverse | 0..1 | boolean | if this is true, then the operation should return all the codes that might be mapped to this code. This parameter reverses the meaning of the source and target parameters \n | |
| OUT | result | 1..1 | boolean | True if the concept could be translated successfully. The value can only be true if at least one returned match has an equivalence which is not unmatched or disjoint \n | |
| OUT | message | 0..1 | string | Error details, for display to a human. If this is provided when result = true, the message carries hints and warnings (e.g. a note that the matches could be improved by providing additional detail) \n | |
| OUT | match | 0..* | A concept in the target value set with an equivalence. Note that there may be multiple matches of equal or differing equivalence, and the matches may include equivalence values that mean that there is no match \n | ||
| OUT | match.equivalence | 0..1 | code | A code indicating the equivalence of the translation, using values from [ConceptMapEquivalence]{concept-map-equivalence.html} \n | |
| OUT | match.concept | 0..1 | Coding | The translation outcome. Note that this would never have userSelected = true, since the process of translations implies that the user is not selecting the code (and only the client could know differently) \n | |
| OUT | match.product | 0..* | Another element that is the product of this mapping \n | ||
| OUT | match.product.element | 0..1 | uri | The element for this product \n | |
| OUT | match.product.concept | 0..1 | Coding | The value for this product \n | |
| OUT | match.source | 0..1 | uri | The canonical URI for the concept map from which this mapping comes from \n |
OPERATION: Fetch Encounter Record
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Encounter-everything
This operation is used to return all the information related to an encounter described in the resource on which this operation is invoked. The response is a bundle of type "searchset". At a minimum, the encounter resource itself is returned, along with any other resources that the server has available for the given encounter for the user. The server also returns whatever resources are needed to support the records - e.g. linked practitioners, locations, organizations etc. The principle intended use for this operation is to provide a patient with access to their record, or to allow a client to retrieve everything for an encounter for efficient display).
\nThe server SHOULD return all resources it has that:
\nIn the US Realm, at a mimimum, the resources returned SHALL include all the data covered by the meaningful use common data elements (see DAF for further guidance). Other applicable implementation guides may make additional rules about the information that is returned. Note that for many resources, the exact nature of the link to encounter can be ambiguous (e.g. for a DiagnosticReport, is it the encounter when it was initiated, or when it was reported?)
\nURL: [base]/Encounter/[id]/$everything
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| OUT | return | 1..1 | Bundle | The bundle type is "searchset" \n |
The key differences between this operation and simply searching the encounter compartment are: * unless the client requests otherwise, the server returns the entire result set in a single bundle (rather than using paging) * the server is responsible for determining what resources to return as included resources (rather than the client specifying which ones)
\nOPERATION: Data Requirements
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Library-data-requirements
The data-requirements operation aggregates and returns the parameters and data requirements for a resource and all its dependencies as a single module definition
\nURL: [base]/$data-requirements
URL: [base]/Library/[id]/$data-requirements
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | target | 0..1 | Reference | The target of the data requirements operation \n | |
| OUT | return | 1..1 | Library | The result of the requirements gathering \n |
The effect of invoking this operation is to determine the aggregate set of data requirements and dependencies for a given target resource. The result is a Library resource with a type of module-definition that contains all the parameter definitions and data requirements of the target resource and any libraries referenced by it. Implementations SHOULD aggregate data requirements intelligently (i.e. by collapsing overlapping data requirements)
\nOPERATION: Find a functional list
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/List-find
This operation allows a client to find an identified list for a particular function by its function. The operation takes two parameters, the identity of a patient, and the name of a functional list. The list of defined functional lists can be found at Current Resource Lists. Applications are not required to support all the lists, and may define additional lists of their own. If the system is able to locate a list that serves the identified purpose, it returns it as the body of the response with a 200 OK status. If the resource cannot be located, the server returns a 404 not found (optionally with an OperationOutcome resource)
\nURL: [base]/List/$find
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | patient | 1..1 | id | The id of a patient resource located on the server on which this operation is executed \n | |
| IN | name | 1..1 | code | The code for the functional list that is being found \n |
Note that servers may support searching by a functional list, and not support this operation that allows clients to find the list directly
\nOPERATION: Data Requirements
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Measure-data-requirements
The data-requirements operation aggregates and returns the parameters and data requirements for the measure and all its dependencies as a single module definition
\nURL: [base]/Measure/[id]/$data-requirements
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | periodStart | 1..1 | date | The start of the measurement period. In keeping with the semantics of the date parameter used in the FHIR search operation, the period will start at the beginning of the period implied by the supplied timestamp. E.g. a value of 2014 would set the period start to be 2014-01-01T00:00:00 inclusive \n | |
| IN | periodEnd | 1..1 | date | The end of the measurement period. The period will end at the end of the period implied by the supplied timestamp. E.g. a value of 2014 would set the period end to be 2014-12-31T23:59:59 inclusive \n | |
| OUT | return | 1..1 | Library | The result of the requirements gathering is a module-definition Library that describes the aggregate parameters, data requirements, and dependencies of the measure \n |
The effect of invoking this operation is to determine the aggregate set of data requirements and dependencies for the measure. The result is a Library resource with a type of module-definition that contains all the parameter definitions and data requirements of the libraries referenced by the measures. Implementations SHOULD aggregate data requirements intelligently (i.e. by collapsing overlapping data requirements)
\nOPERATION: Evaluate Measure
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Measure-evaluate-measure
The evaluate-measure operation is used to invoke an eMeasure and obtain the results
\nURL: [base]/Measure/$evaluate-measure
URL: [base]/Measure/[id]/$evaluate-measure
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | periodStart | 1..1 | date | The start of the measurement period. In keeping with the semantics of the date parameter used in the FHIR search operation, the period will start at the beginning of the period implied by the supplied timestamp. E.g. a value of 2014 would set the period start to be 2014-01-01T00:00:00 inclusive \n | |
| IN | periodEnd | 1..1 | date | The end of the measurement period. The period will end at the end of the period implied by the supplied timestamp. E.g. a value of 2014 would set the period end to be 2014-12-31T23:59:59 inclusive \n | |
| IN | measure | 0..1 | Reference | The measure to evaluate. This parameter is only required when the operation is invoked on the resource type, it is not used when invoking the operation on a Measure instance \n | |
| IN | reportType | 0..1 | code | The type of measure report, patient, patient-list, or population. If not specified, a default value of patient will be used if the patient parameter is supplied, otherwise, population will be used \n | |
| IN | patient | 0..1 | Reference | Patient to evaluate against. If not specified, the measure will be evaluated for all patients that meet the requirements of the measure. If specified, only the referenced patient will be evaluated \n | |
| IN | practitioner | 0..1 | Reference | Practitioner to evaluate. If specified, the measure will be evaluated only for patients whose primary practitioner is the identified practitioner \n | |
| IN | lastReceivedOn | 0..1 | dateTime | The date the results of this measure were last received. This parameter is only valid for patient-level reports and is used to indicate when the last time a result for this patient was received. This information can be used to limit the set of resources returned for a patient-level report \n | |
| OUT | return | 1..1 | MeasureReport | The results of the measure calculation. See the MeasureReport resource for a complete description of the output of this operation \n |
The effect of invoking this operation is to calculate the measure for the given patient, or all patients if no patient is supplied, and return the results as a MeasureReport resource of the appropriate type
\nOPERATION: Process Message
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/MessageHeader-process-message
This operation accepts a message, processes it according to the definition of the event in the message header, and returns a one or more response messages. This operation is described in detail on the messaging page
\nURL: [base]/$process-message
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | content | 1..1 | Bundle | The message to process (or, if using asynchronous messaging, it may be a response message to accept) \n | |
| IN | async | 0..1 | boolean | If 'true' the message is processed using the asynchronous messaging pattern \n | |
| IN | response-url | 0..1 | uri | A URL to submit response messages to, if asynchronous messaging is being used, and if the MessageHeader.source.endpoint is not the appropriate place to submit responses \n | |
| OUT | return | 0..1 | Bundle | A response message, if synchronous messaging is being used (mandatory in this case). For asynchronous messaging, there is no return value \n |
This operation does not use the parameters resource; the parameters "async" and "response-url" always go in the URL, if they are used, and the message parameter is always the body of the HTTP message
\nOPERATION: Last N Observations Query
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Observation-lastn
The lastn query meets the common need for searching for the most recent or last n=number of observations for a subject. For example, retrieving the last 5 temperatures for a patient to view trends or fetching the most recent laboratory results or vitals signs. To ask a server to return the last n=number of observations, the lastn queryuses the normal search parameters defined for the Observation resource. However, rather than their normal use, they are interpreted as inputs - i.e.. instead of requiring that the resources literally contain the search parameters, they are passed to a server algorithm of some kind that uses them to determine the most appropriate matches.
\nThe response from an lastn query is a set of observations:
\nObservation.codeThe set of returned observations should represent distinct real world observations and not the same observation with changes in status or versions. If there are no matches, the lastn query SHALL return an empty search set with no error, but may include an operation outcome with further advice.
\nURL: [base]/Observation/$lastn
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | max | 0..1 | positiveInt |
| |
| OUT | return | 1..1 | Bundle | The set of most recent N Observations that match the lastn query search criteria. \n |
The key differences between this query operation and simply searching Observation using the combination of _count and _sort parameters are:
This operation cannot be performed on observations that the user is not authorized to see. It is assumed that the server has identified and secured the context appropriately, and can either associate the authorization context with a single patient, or determine whether the context has the rights to the nominated patient, if there is one. If there is no nominated patient (e.g. the operation is invoked at the system level) and the context is not associated with a single patient record, then the server should return an error. Specifying the relationship between the context, a user and patient records is outside the scope of this specification.
\nOPERATION: Observation Statistics
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Observation-stats
The Statistics operation performs a set of statistical calculations on a set of clinical measurements such as a blood pressure as stored on the server. This operation is focused on Observation resources with valueQuantity elements that have UCUM unit codes.
\nThe set of Observations is defined by 4 parameters:
\nsubject)code and system, or coding)'duration or period)statistic)Possible statistical analyses (see StatisticsCode):
\nIf successful, the operation returns an Observation resource for each code with the results of the statistical calculations as component value pairs where the component code = the statistical code. The Observation also contains the input parameters patient,code and duration parameters. If unsuccessful, an OperationOutcome with an error message will be returned.
The client can request that all the observations on which the statistics are based be returned as well, using the include parameter. If an include parameter is specified, a limit may also be specified; the sources observations are subsetted at the server's discretion if count > limit. This functionality is included with the intent of supporting graphical presentation
\nURL: [base]/Observation/$stats
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | subject | 1..1 | uri | The subject of the relevant Observations, which has the value of the Observation.subject.reference. E.g. 'Patient/123'. Reference can be to an absolute URL, but servers only perform stats on their own observations \n | |
| IN | code | 0..* | string | The test code(s) upon which the statistics are being performed. Provide along with a system, or as a coding. For example, the code = "45667-2" will evaluate all relevant Observations with this code in Observation.code. For LOINC codes that are panels, (e.g. 55284-4) this means to include all the individual codes that are part of a panel \n | |
| IN | system | 0..1 | uri | The system for the code(s). Or provide a coding instead \n | |
| IN | coding | 0..* | Coding | The test code upon which the statistics are being performed, as a Coding \n | |
| IN | duration | 0..1 | decimal | The time period of interest given as hours. For example, the duration = "1" represents the last hour - the time period from on hour ago to now \n | |
| IN | period | 0..1 | Period | The time period over which the calculations to be performed, if a duration is not provided \n | |
| IN | statistic | 1..* | code | average|max|min|count The statistical operations to be performed on the relevant operations. Multiple statistics operations can be specified. These codes are defined here \n | |
| IN | include | 0..1 | boolean | Whether to return the observations on which the statistics are based \n | |
| IN | limit | 0..1 | positiveInt | If an include parameter is specified, a limit may also be specified to limit the number of source Observations returned. If the include paramter is absent or equal to "false" the limit parameter SHALL be ignored by the server \n | |
| OUT | return | 1..* | Observation | A set of observations, one observation for each code, each containing one component for each statistic. The Observation.component.code contains the statistic, and is relative to the Observation.code and cannot be interpreted independently. The Observation will also contain a subject, effectivePeriod, and code reflecting the input parameters. The status is fixed to | |
| OUT | source | 0..* | Observation | Source observations on which the statistics are based \n |
This operation cannot be performed on observations that the user is not authorized to see. It is assumed that the server has identified and secured the context appropriately, and can either associate the authorization context with a single patient, or determine whether the context has the rights to the nominated patient, if there is one. If there is no nominated patient (e.g. the operation is invoked at the system level) and the context is not associated with a single patient record, then the server should return an error. Specifying the relationship between the context, a user and patient records is outside the scope of this specification.
\nOPERATION: Fetch Patient Record
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Patient-everything
This operation is used to return all the information related to the patient described in the resource on which this operation is invoked. The response is a bundle of type "searchset". At a minimum, the patient resource itself is returned, along with any other resources that the server has that are related to the patient, and that are available for the given user. The server also returns whatever resources are needed to support the records - e.g. linked practitioners, medications, locations, organizations etc. The principle intended use for this operation is to provide a patient with access to their entire record (e.g. "Blue Button"). The server SHOULD return at least all resources that it has that are in the patient compartment for the identified patient, and any resource referenced from those, including binaries and attachments. In the US Realm, at a mimimum, the resources returned SHALL include all the data covered by the meaningful use common data elements as defined in DAF. Other applicable implementation guides may make additional rules about how much information that is returned
\nURL: [base]/Patient/$everything
URL: [base]/Patient/[id]/$everything
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | start | 0..1 | date | The date range relates to care dates, not record currency dates - e.g. all records relating to care provided in a certain date range. If no start date is provided, all records prior to the end date are in scope. \n | |
| IN | end | 0..1 | date | The date range relates to care dates, not record currency dates - e.g. all records relating to care provided in a certain date range. If no end date is provided, all records subsequent to the start date are in scope. \n | |
| OUT | return | 1..1 | Bundle | The bundle type is "searchset" \n |
The key differences between this operation and simply searching the patient compartment are:
It is assumed that the server has identified and secured the context appropriately, and can either associate the authorization context with a single patient, or determine whether the context has the rights to the nominated patient, if there is one. If there is no nominated patient (e.g. the operation is invoked at the system level) and the context is not associated with a single patient record, then the server should return an error. Specifying the relationship between the context, a user and patient records is outside the scope of this specification.
\nOPERATION: Find patient matches using MPI based logic
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Patient-match
A Master Patient Index (MPI ) is a service used to manage patient identification in a context where multiple patient databases exist. Healthcare applications and middleware use the MPI to match patients between the databases, and as new patient details are encountered. MPIs are highly specialized applications, often tailored extensively to the institution's particular mix of patients. MPIs can also be run on a regional and national basis.\\n\\nTo ask an MPI to match a patient, clients use the \\"$match\\" operation, which accepts a patient resource which may be only partially complete. The data provided is interpreted as an MPI input and passed processed by an algorithm of some kind that uses the data to determine the most appropriate matches in the patient set. \\n\\nNote that different MPI matching algorithms have different required inputs. The generic $match operation does not specify any particular algorithm, nor a minimum set of information that must be provided when asking for an MPI match operation to be performed, but may implementations will have a set of minimum information, which may be declared in their definition of the $match operation by specifying a profile on the resource parameter, indicating which properties are required in the search.\\n\\nThe patient resource coming into the operation does not have to be complete, nor does it need to pass validation (i.e. Mandatory fields don't need to be populated), but it does have to be a valid instance. This is due to the resource being used for reference data to match from, and not being stored.
\nURL: [base]/Patient/$match
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | resource | 1..1 | Resource | Use this to provide an entire set of patient details for the MPI to match against (e.g. POST a patient record to Patient/$match). If a patient record is not provided, then one or more of the other parameters must be provided \n | |
| IN | onlyCertainMatches | 0..1 | boolean | If there are multiple potential matches, then the match should not return the results with this flag set to true. \nWhen false, the server may return multiple results with each result graded accordingly. \n | |
| IN | count | 0..1 | integer | The maximum number of records to return. If no value is provided, the server decides how many matches to return. Note that clients should be careful when using this, as it may prevent probable - and valid - matches from being returned \n | |
| OUT | return | 1..1 | Bundle | A bundle contain a set of Patient records that represent possible matches, optionally it may also contain an OperationOutcome with further information about the search results (such as warnings or information messages, such as a count of records that were close but eliminated) \nIf the operation was unsuccessful, then an OperationOutcome may be returned along with a BadRequest status Code (e.g. security issue, or insufficient properties in patient fragment - check against profile) \n |
The response from an "mpi" query is a bundle containing patient records, ordered from most likely to least likely. If there are no patient matches, the MPI SHALL return an empty search set with no error, but may include an operation outcome with further advice regarding patient selection. All patient records SHALL have a search score from 0 to 1, where 1 is the most certain match, along with an extension "match-grade" that indicates the MPI's position on the match quality.
\nOPERATION: Apply
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/PlanDefinition-apply
The apply operation applies a PlanDefinition to a given context
\nURL: [base]/PlanDefinition/[id]/$apply
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | patient | 1..1 | Reference | The patient that is the target of the plan to be applied \n | |
| IN | encounter | 0..1 | Reference | The encounter in context, if any \n | |
| IN | practitioner | 0..1 | Reference | The practitioner applying the plan definition \n | |
| IN | organization | 0..1 | Reference | The organization applying the plan definition \n | |
| IN | userType | 0..1 | CodeableConcept | The type of user initiating the request, e.g. patient, healthcare provider, or specific type of healthcare provider (physician, nurse, etc.) \n | |
| IN | userLanguage | 0..1 | CodeableConcept | Preferred language of the person using the system \n | |
| IN | userTaskContext | 0..1 | CodeableConcept | The task the system user is performing, e.g. laboratory results review, medication list review, etc. This information can be used to tailor decision support outputs, such as recommended information resources \n | |
| IN | setting | 0..1 | CodeableConcept | The current setting of the request (inpatient, outpatient, etc) \n | |
| IN | settingContext | 0..1 | CodeableConcept | Additional detail about the setting of the request, if any \n | |
| OUT | return | 1..1 | CarePlan | The CarePlan that is the result of applying the plan definition \n |
The result of this operation is a CarePlan resource, with activities for each of the applicable actions based on evaluating the applicability condition in context. For each applicable action, the activitydefinition is applied as described in the $apply operation of the ActivityDefinition resource, and the resulting resource is added as an activity to the CarePlan. If the ActivityDefinition includes library references, those libraries will be available to the evaluated expressions. If those libraries have parameters, those parameters will be bound by name to the parameters given to the operation
\nOPERATION: Data Requirements
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/PlanDefinition-data-requirements
The data-requirements operation aggregates and returns the parameters and data requirements for the plan definition and all its dependencies as a single module definition library
\nURL: [base]/PlanDefinition/[id]/$data-requirements
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| OUT | return | 1..1 | Library | The result of the requirements gathering is a module-definition Library that describes the aggregate parameters, data requirements, and dependencies of the plan definition \n |
The effect of invoking this operation is to determine the aggregate set of data requirements and dependencies for the plan definition. The result is a Library resource with a type of module-definition that contains all the parameter definitions and data requirements of the plan definition and any libraries referenced by it. Implementations SHOULD aggregate data requirements intelligently (i.e. by collapsing overlapping data requirements)
\nOPERATION: Populate Questionnaire
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Questionnaire-populate
Generates a QuestionnaireResponse instance based on a specified Questionnaire, filling in answers to questions where possible based on information provided as part of the operation or already known by the server about the subject of the Questionnaire.
\nIf the operation is not called at the instance level, one and only one of the identifier, questionnaire or questionnaireRef 'in' parameters must be provided. If called at the instance level, these parameters will be ignored.
\nThe response will contain a QuestionnaireResponse instance based on the specified Questionnaire and/or an OperationOutcome resource with errors or warnings.
\nThe QuestionnaireResponse instance will be populated with an unanswered set of questions following the group and question structure of the specified Questionnaire. If content parameters were specified or the local parameter was set to true, some of the questions may have answers filled in as well. In the case of repeating questions or groups, typically only one repetition will be provided unless answer values exist that would support populating multiple repetitions.
\nPopulation of the QuestionnaireResponse with appropriate data is dependent on the questions and/or groups in the Questionnaire having metadata that allows the server to recognize the questions, e.g. through Questionnaire.item.definition or through use of the ConceptMap resource.
\nRegardless of the mechanism used to link the questions in a questionnaire to a "known" mappable concept, solutions using this operation should ensure that the details of the question and associated linkage element are sufficiently similar as to safely allow auto-population; i.e. the question text and context must be sufficiently the same, the value set for the question must fall within the value set for the mapped element, the data types must be the same or convertible, etc.
\nURL: [base]/Questionnaire/$populate
URL: [base]/Questionnaire/[id]/$populate
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | identifier | 0..1 | uri | A logical questionnaire identifier (i.e. ''Questionnaire.identifier''). The server must know the questionnaire or be able to retrieve it from other known repositories. \n | |
| IN | questionnaire | 0..1 | Questionnaire | The Questionnaire is provided directly as part of the request. Servers may choose not to accept questionnaires in this fashion \n | |
| IN | questionnaireRef | 0..1 | Reference | The Questionnaire is provided as a resource reference. Servers may choose not to accept questionnaires in this fashion or may fail if they cannot resolve or access the referenced questionnaire. \n | |
| IN | subject | 1..1 | Reference | The resource that is to be the QuestionnaireResponse.subject. The QuestionnaireResponse instance will reference the provided subject. In addition, if the local parameter is set to true, server information about the specified subject will be used to populate the instance. \n | |
| IN | content | 0..* | Reference | Resources containing information to be used to help populate the QuestionnaireResponse. These may be FHIR resources or may be binaries containing FHIR documents, CDA documents or other source materials. Servers may not support all possible source materials and may ignore materials they do not recognize. (They MAY provide warnings if ignoring submitted resources.) \n | |
| IN | local | 0..1 | boolean | If specified and set to 'true' (and the server is capable), the server should use what resources and other knowledge it has about the referenced subject when pre-populating answers to questions. \n | |
| OUT | questionnaire | 1..1 | QuestionnaireResponse | The partially (or fully)-populated set of answers for the specified Questionnaire \n | |
| OUT | issues | 0..1 | OperationOutcome | A list of hints and warnings about problems encountered while populating the questionnaire. These might be show to the user as an advisory note. Note: if the questionnaire cannot be populated at all, then the operation should fail, and an OperationOutcome is returned directly with the failure, rather than using this parameter \n |
While it is theoretically possible for a QuestionnaireResponse instance to be completely auto-populated and submitted without human review, the intention of this transaction is merely to reduce redundant data entry. A client SHOULD ensure that a human submitter has an opportunity to review the auto-populated answers to confirm correctness as well as to complete or expand on information provided by the auto-population process.
\nWhen creating an "empty" questionnaire, the general algorithm is to create a QuestionnaireResponse with one item for every item in the source Questionnaire, including items with "enableWhen", "display" items, etc. If a question has a default, the default answer should be populated. And the QuestionnaireResponse should point back to the originating Questionnaire. Repeating items will typically only include a single repetition. Other extensions and/or elements may also be populated if the system is aware of appropriate values.
\nComplex form designs with conditional logic or tight constraints on cardinalities may be challenging to auto-populate. A server MAY choose to traverse the questionnaire as if it were a human respondent, answering only those questions that are enabled based on previously answered questions. However, doing so may result in minimal population. Alternatively, systems may choose to populate all known answers, independent of dependencies and other constraints. This may cause questions to be answered that should not be answered. It will be up to the client to appropriately prune the final populated questionnaire once human review has taken place.
\nInvoking this operation with the ''content'' parameter may involve the disclosure of personally identifiable healthcare information to the system which is performing the population process. No such disclosures should be made unless the system on which the operation is being invoked is a "trusted" system and appropriate agreements are in place to protect the confidentiality of any information shared with that system.
\nOPERATION: Generate HTML for Questionnaire
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Questionnaire-populatehtml
Generates an HTML page as a Binary instance based on a specified Questionnaire, filling in answers to questions where possible based on information provided as part of the operation or already known by the server about the subject of the Questionnaire.
\nIf the operation is not called at the instance level, one and only one of the identifier, questionnaire or questionnaireRef 'in' parameters must be provided. If called at the instance level, these parameters will be ignored.
\nThe response will contain a Binary instance containing an HTML page for filling in and submitting the specified Questionnaire and/or an OperationOutcome resource with errors or warnings.
\nThe generated HTML form instance will be populated with an unanswered set of questions following the group and question structure of the specified Questionnaire. If content parameters were specified or the local parameter was set to true, some of the questions may have answers filled in as well. In the case of repeating questions or groups, typically only one repetition will be provided unless answer values exist that would support populating multiple repetitions.
\nPopulation of the HTML form with appropriate data is dependent on the questions and/or groups in the Questionnaire having metadata that allows the server to recognize the questions, e.g. through Questionnaire.item.definition or through use of the ConceptMap resource.
\nRegardless of the mechanism used to link the questions in a questionnaire to a "known" mappable concept, solutions using this operation should ensure that the details of the question and associated linkage element are sufficiently similar as to safely allow auto-population; i.e. the question text and context must be sufficiently the same, the value set for the question must fall within the value set for the mapped element, the data types must be the same or convertible, etc.
\nURL: [base]/Questionnaire/$populatehtml
URL: [base]/Questionnaire/[id]/$populatehtml
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | identifier | 0..1 | uri | A logical questionnaire identifier (i.e. ''Questionnaire.identifier''). The server must know the questionnaire or be able to retrieve it from other known repositories. \n | |
| IN | questionnaire | 0..1 | Questionnaire | The Questionnaire is provided directly as part of the request. Servers may choose not to accept questionnaires in this fashion \n | |
| IN | questionnaireRef | 0..1 | Reference | The Questionnaire is provided as a resource reference. Servers may choose not to accept questionnaires in this fashion or may fail if they cannot resolve or access the referenced questionnaire. \n | |
| IN | content | 0..* | Reference | Resources containing information to be used to help populate the generated HTML form. These may be FHIR resources or may be binaries containing FHIR documents, CDA documents or other source materials. Servers may not support all possible source materials and may ignore materials they do not recognize. (They MAY provide warnings if ignoring submitted resources.) \n | |
| IN | local | 0..1 | boolean | If specified and set to 'true' (and the server is capable), the server should use what resources and other knowledge it has about the referenced subject when pre-populating answers to questions. \n | |
| OUT | form | 1..1 | Binary | The generated HTML page that supports capturing the information defined by questionnaire, possibly partially (or fully)-populated with a set of answers for the specified Questionnaire \n | |
| OUT | issues | 0..1 | OperationOutcome | A list of hints and warnings about problems encountered while populating the questionnaire. These might be show to the user as an advisory note. Note: if the questionnaire cannot be populated at all, then the operation should fail, and an OperationOutcome is returned directly with the failure, rather than using this parameter \n |
While it is theoretically possible for an HTML form to be completely auto-populated and submitted without human review, the intention of this transaction is merely to reduce redundant data entry. The HTML form SHOULD ensure that a human submitter has an opportunity to review the auto-populated answers to confirm correctness as well as to complete or expand on information provided by the auto-population process.
\nComplex form designs with conditional logic or tight constraints on cardinalities may be challenging to auto-populate. A server MAY choose to traverse the questionnaire as if it were a human respondent, answering only those questions that are enabled based on previously answered questions. However, doing so may result in minimal population. Alternatively, systems may choose to populate all known answers, independent of dependencies and other constraints. This may cause questions to be answered that should not be answered. The generated HTML form is responsible for pruning the final populated questionnaire once human review has taken place.
\nInvoking this operation with the ''content'' parameter may involve the disclosure of personally identifiable healthcare information to the system which is performing the population process. No such disclosures should be made unless the system on which the operation is being invoked is a "trusted" system and appropriate agreements are in place to protect the confidentiality of any information shared with that system.
\nOPERATION: Generate a link to a Questionnaire completion webpage
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Questionnaire-populatelink
Generates a link to a web page to be used to answer a specified Questionnaire. The form at the specified location will be pre-filled with answers to questions where possible based on information provided as part of the operation or already known by the server about the subject of the Questionnaire.
\nIf the operation is not called at the instance level, one and only one of the identifier, questionnaire or questionnaireRef 'in' parameters must be provided. If called at the instance level, these parameters will be ignored.
\nThe response will contain a url for the web page to direct the user to. The page will allow the user to complete/verify the questionnaire answers and to submit the form.
\nThe specified page will be populated with an unanswered set of questions following the group and question structure of the specified Questionnaire. If content parameters were specified or the local parameter was set to true, some of the questions may have answers filled in as well. In the case of repeating questions or groups, typically only one repetition will be provided unless answer values exist that would support populating multiple repetitions.
\nPopulation of the page with appropriate data is dependent on the questions and/or groups in the Questionnaire having metadata that allows the server to recognize the questions, e.g. through Questionnaire.item.definition or through use of the ConceptMap resource.
\nRegardless of the mechanism used to link the questions in a questionnaire to a "known" mappable concept, solutions using this operation should ensure that the details of the question and associated linkage element are sufficiently similar as to safely allow auto-population; i.e. the question text and context must be sufficiently the same, the value set for the question must fall within the value set for the mapped element, the data types must be the same or convertible, etc.
\nURL: [base]/Questionnaire/$populatelink
URL: [base]/Questionnaire/[id]/$populatelink
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | identifier | 0..1 | uri | A logical questionnaire identifier (i.e. ''Questionnaire.identifier''). The server must know the questionnaire or be able to retrieve it from other known repositories. \n | |
| IN | questionnaire | 0..1 | Questionnaire | The Questionnaire is provided directly as part of the request. Servers may choose not to accept questionnaires in this fashion \n | |
| IN | questionnaireRef | 0..1 | Reference | The Questionnaire is provided as a resource reference. Servers may choose not to accept questionnaires in this fashion or may fail if they cannot resolve or access the referenced questionnaire. \n | |
| IN | content | 0..* | Reference | Resources containing information to be used to help populate the generated HTML form. These may be FHIR resources or may be binaries containing FHIR documents, CDA documents or other source materials. Servers may not support all possible source materials and may ignore materials they do not recognize. (They MAY provide warnings if ignoring submitted resources.) \n | |
| IN | local | 0..1 | boolean | If specified and set to 'true' (and the server is capable), the server should use what resources and other knowledge it has about the referenced subject when pre-populating answers to questions. \n | |
| OUT | link | 1..1 | uri | The URL for the web form that supports capturing the information defined by questionnaire, possibly partially (or fully)-populated with a set of answers for the specified Questionnaire \n | |
| OUT | issues | 0..1 | OperationOutcome | A list of hints and warnings about problems encountered while populating the questionnaire. These might be show to the user as an advisory note. Note: if the questionnaire cannot be populated at all, then the operation should fail, and an OperationOutcome is returned directly with the failure, rather than using this parameter \n |
While it is theoretically possible for the questionnaire response to be completely auto-populated and submitted without human review, the intention of this transaction is merely to reduce redundant data entry. The web page SHOULD ensure that a human submitter has an opportunity to review the auto-populated answers to confirm correctness as well as to complete or expand on information provided by the auto-population process.
\nComplex form designs with conditional logic or tight constraints on cardinalities may be challenging to auto-populate. A server MAY choose to traverse the questionnaire as if it were a human respondent, answering only those questions that are enabled based on previously answered questions. However, doing so may result in minimal population. Alternatively, systems may choose to populate all known answers, independent of dependencies and other constraints. This may cause questions to be answered that should not be answered. The web form is responsible for pruning the final populated questionnaire once human review has taken place.
\nInvoking this operation with the ''content'' parameter may involve the disclosure of personally identifiable healthcare information to the system which is performing the population process. No such disclosures should be made unless the system on which the operation is being invoked is a "trusted" system and appropriate agreements are in place to protect the confidentiality of any information shared with that system.
\nOPERATION: Access a list of profiles, tags, and security labels
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Resource-meta
This operation retrieves a summary of the profiles, tags, and security labels for the given scope; e.g. for each scope:
URL: [base]/$meta
URL: [base]/Resource/$meta
URL: [base]/Resource/[id]/$meta
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| OUT | return | 1..1 | Meta | The meta returned by the operation \n |
At the system and type levels, the $meta operation is used to get a summary of all the labels that are in use across the system. The principle use for this operation is to support search e.g. what tags can be searched for. At these levels, the meta will not contain versionId, lastUpdated etc. Systems are not obligated to implement the operation at this level (and should return a 4xx error if they don't). At the resource and historical entry level, the $meta operation returns the same meta as would be returned by accessing the resource directly. This can be used to allow a system to get access to the meta-information for the resource without accessing the resource itself, e.g. for security reasons
\nOPERATION: Add profiles, tags, and security labels to a resource
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Resource-meta-add
This operation takes a meta, and adds the profiles, tags, and security labels found in it to the nominated resource. This operation can also be used on historical entries - to update them without creating a different historical version
\nURL: [base]/Resource/[id]/$meta-add
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | meta | 1..1 | Meta | Profiles, tags, and security labels to add to the existing resource. Note that profiles, tags, and security labels are sets, and duplicates are not created. The identity of a tag or security label is the system+code. When matching existing tags during adding, version and display are ignored. For profiles, matching is based on the full URL \n | |
| OUT | return | 1..1 | Meta | Resulting meta for the resource \n |
This operation is special in that executing this operation does not cause a new version of the resource to be created. The meta is updated directly. This is because the content in meta does not affect the meaning of the resource, and the security labels (in particular) are used to apply access rules to existing versions of resources
\nOPERATION: Delete profiles, tags, and security labels for a resource
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Resource-meta-delete
This operation takes a meta, and deletes the profiles, tags, and security labels found in it from the nominated resource. This operation can also be used on historical entries
\nURL: [base]/Resource/[id]/$meta-delete
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | meta | 1..1 | Meta | Profiles, tags, and security labels to delete from the existing resource. It is not an error if these tags, profiles, and labels do not exist. The identity of a tag or security label is the system+code. When matching existing tags during deletion, version and display are ignored. For profiles, matching is based on the full URL \n | |
| OUT | return | 1..1 | Meta | Resulting meta for the resource \n |
This operation is special in that executing this operation does not cause a new version of the resource to be created. The meta is updated directly. This is because the content in meta does not affect the meaning of the resource, and the security labels (in particular) are used to apply access rules to existing versions of resources
\nOPERATION: Validate a resource
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/Resource-validate
The validate operation checks whether the attached content would be acceptable either generally, as a create, an update or as a delete to an existing resource. The action the server takes depends on the mode parameter:
Modes update and delete can only be used when the operation is invoked at the resource instance level. The return from this operation is an OperationOutcome
\nURL: [base]/Resource/$validate
URL: [base]/Resource/[id]/$validate
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | resource | 0..1 | Resource | Must be present unless the mode is "delete" \n | |
| IN | mode | 0..1 | code | http://hl7.org/fhir/ValueSet/resource-validation-mode (Required) | Default is 'no action'; (e.g. general validation) \n |
| IN | profile | 0..1 | uri | If this is nominated, then the resource is validated against this specific profile. If a profile is nominated, and the server cannot validate against the nominated profile, it SHALL return an error \n | |
| OUT | return | 1..1 | OperationOutcome | If the operation outcome does not list any errors, and a mode was specified, then this is an indication that the operation would be expected to succeed (excepting for transactional integrity issues, see below) \n |
This operation may be used during design and development to validate application design. It can also be used at run-time. One possible use might be that a client asks the server whether a proposed update is valid as the user is editing a dialog and displays an updated error to the user. The operation can be used as part of a light-weight two phase commit protocol but there is no expectation that the server will hold the content of the resource after this operation is used, or that the server guarantees to successfully perform an actual create, update or delete after the validation operation completes.
\nThis operation returns a 200 OK whether or not the resource is valid. A 4xx or 5xx error means that the validation itself could not be performed, and it is unknown whether the resource is valid or not.
\nOPERATION: Data Requirements
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/ServiceDefinition-data-requirements
The data-requirements operation aggregates and returns the parameters and data requirements for the service module and all its dependencies as a single module definition library.
\nURL: [base]/ServiceDefinition/[id]/$data-requirements
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | evaluateAtDateTime | 0..1 | dateTime | An optional date and time specifying that the evaluation should be performed as though it was the given date and time. Data requirements returned will use this as the "Now" point for the purposes of determining the data requirements. \n | |
| OUT | return | 1..1 | Library | The result of the requirements gathering is a module-definition Library that describes the aggregate parameters, data requirements, and dependencies of the service. \n |
The effect of invoking this operation is to determine the aggregate set of data requirements and dependencies for the service module. The result is a Library resource with a type of module-definition that contains all the parameter definitions and data requirements of the service module and any libraries referenced by it. Implementations SHOULD aggregate data requirements intelligently (i.e. by collapsing overlapping data requirements).
\nOPERATION: Evaluate
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/ServiceDefinition-evaluate
The evaluate operation requests clinical decision support guidance based on a specific decision support module
\nURL: [base]/ServiceDefinition/[id]/$evaluate
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | requestId | 0..1 | id | An optional client-provided identifier to track the request. \n | |
| IN | evaluateAtDateTime | 0..1 | dateTime | An optional date and time specifying that the evaluation should be performed as though it was the given date and time. The most direct implication of this is that references to "Now" within the evaluation logic of the module should result in this value. In addition, wherever possible, the data accessed by the module should appear as though it was accessed at this time. The evaluateAtDateTime value may be any time in the past or future, enabling both retrospective and prospective scenarios. If no value is provided, the date and time of the request is assumed. \n | |
| IN | inputParameters | 0..1 | Parameters | The input parameters for a request, if any. These parameters are defined by the module that is the target of the evaluation, and typically supply patient-independent information to the module. \n | |
| IN | inputData | 0..* | Any | The input data for the request. These data are defined by the data requirements of the module and typically provide patient-dependent information. \n | |
| IN | patient | 0..1 | Reference | The patient in context, if any. \n | |
| IN | encounter | 0..1 | Reference | The encounter in context, if any. \n | |
| IN | initiatingOrganization | 0..1 | Reference | The organization initiating the request. \n | |
| IN | initiatingPerson | 0..1 | Reference | The person initiating the request. \n | |
| IN | userType | 0..1 | CodeableConcept | The type of user initiating the request, e.g. patient, healthcare provider, or specific type of healthcare provider (physician, nurse, etc.). \n | |
| IN | userLanguage | 0..1 | CodeableConcept | Preferred language of the person using the system. \n | |
| IN | userTaskContext | 0..1 | CodeableConcept | The task the system user is performing, e.g. laboratory results review, medication list review, etc. This information can be used to tailor decision support outputs, such as recommended information resources. \n | |
| IN | receivingOrganization | 0..1 | Reference | The organization that will receive the response. \n | |
| IN | receivingPerson | 0..1 | Reference | The person in the receiving organization that will receive the response. \n | |
| IN | recipientType | 0..1 | CodeableConcept | The type of individual that will consume the response content. This may be different from the requesting user type (e.g. if a clinician is getting disease management guidance for provision to a patient). E.g. patient, healthcare provider or specific type of healthcare provider (physician, nurse, etc.). \n | |
| IN | recipientLanguage | 0..1 | CodeableConcept | Preferred language of the person that will consume the content. \n | |
| IN | setting | 0..1 | CodeableConcept | The current setting of the request (inpatient, outpatient, etc). \n | |
| IN | settingContext | 0..1 | CodeableConcept | Additional detail about the setting of the request, if any. \n | |
| OUT | return | 1..1 | GuidanceResponse | The result of the request as a GuidanceResponse resource. \n |
OPERATION: Build Questionnaire
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/StructureDefinition-questionnaire
Generates a Questionnaire instance based on a specified StructureDefinition, creating questions for each core element or extension element found in the StructureDefinition. If the operation is not called at the instance level, one of the identifier, profile or url 'in' parameters must be provided. If more than one is specified, servers may raise an error or may resolve with the parameter of their choice. If called at the instance level, these parameters will be ignored. The response will contain a Questionnaire instance based on the specified StructureDefinition and/or an OperationOutcome resource with errors or warnings. Nested groups are used to handle complex structures and data types. If the 'supportedOnly' parameter is set to true, only those elements marked as "must support" will be included. This operation is intended to enable auto-generation of simple interfaces for arbitrary profiles. The 'questionnaire' approach to data entry has limitations that will make it less optimal than custom-defined interfaces. However, this function may be useful for simple applications or for systems that wish to support "non-core" resources with minimal development effort.
\nURL: [base]/StructureDefinition/$questionnaire
URL: [base]/StructureDefinition/[id]/$questionnaire
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | identifier | 0..1 | uri | A logical profile identifier (i.e. 'StructureDefinition.identifier''). The server must know the profile or be able to retrieve it from other known repositories. \n | |
| IN | profile | 0..1 | string | The StructureDefinition is provided directly as part of the request. Servers may choose not to accept profiles in this fashion \n | |
| IN | url | 0..1 | uri | The profile's official URL (i.e. 'StructureDefinition.url'). The server must know the profile or be able to retrieve it from other known repositories. \n | |
| IN | supportedOnly | 0..1 | boolean | If true, the questionnaire will only include those elements marked as "mustSupport='true'" in the StructureDefinition. \n | |
| OUT | return | 1..1 | Questionnaire | The questionnaire form generated based on the StructureDefinition. \n |
Open Issue: Ideally, extensions should be populated in the generated Questionnaire that will support taking QuestionnaireResponse resources generated from the Questionnaire and turning them back into the appropriate resources.
\nOPERATION: Model Instance Transformation
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/StructureMap-transform
The transform operation takes input content, applies a structure map transform, and then returns the output.
\nURL: [base]/StructureMap/$transform
URL: [base]/StructureMap/[id]/$transform
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | source | 0..1 | uri | The structure map to apply. This is only needed if the operation is invoked at the resource level. If the $transform operation is invoked on a particular structure map, this will be ignored by the server \n | |
| IN | content | 1..1 | Resource | The logical content to transform \n | |
| OUT | return | 1..1 | Resource | The result of the transform \n |
The input and return are specified as 'Resources'. In most usage of the $transform operation, either the input or return content is not a valid FHIR resource. In these cases, the return type is actually a Binary resource. For this operation, the Binary resources may be encoded directly, using a mime-type, as shown in the example. Note: this specification does not yet address the means by which the servers may know the correct mime types for the various content involved
\nOPERATION: Value Set Expansion
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/ValueSet-expand
The definition of a value set is used to create a simple collection of codes suitable for use for data entry or validation. If the operation is not called at the instance level, one of the in parameters identifier, context or valueset must be provided. An expanded value set will be returned, or an OperationOutcome with an error message.
\nURL: [base]/ValueSet/$expand
URL: [base]/ValueSet/[id]/$expand
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | url | 0..1 | uri | A canonical url for a value set. The server must know the value set (e.g. it is defined explicitly in the server's value sets, or it is defined implicitly by some code system known to the server \n | |
| IN | valueSet | 0..1 | ValueSet | The value set is provided directly as part of the request. Servers may choose not to accept value sets in this fashion \n | |
| IN | context | 0..1 | uri | The context of the value set, so that the server can resolve this to a value set to expand. The recommended format for this URI is [Structure Definition URL]#[name or path into structure definition] e.g. http://hl7.org/fhir/StructureDefinition/observation-hspc-height-hspcheight#Observation.interpretation. Other forms may be used but are not defined. This form is only usable if the terminology server also has access to the profile registry that the server is using, but can be used to delegate the mapping from an application context to a binding at run-time \n | |
| IN | filter | 0..1 | string | A text filter that is applied to restrict the codes that are returned (this is useful in a UI context). The interpretation of this is delegated to the server in order to allow to determine the most optimal search approach for the context \n | |
| IN | profile | 0..1 | uri | A reference to an external definition that provides additional control information about how the expansion is performed. At this time, there is no agreed format or functionality for the target of this URI. The VSAC Documentation provides one example of the use of this parameter. Implementers using this element will need to agree on an appropriate mechanism for use within their interoperability community. Known uses for profile include: * whether to return the value set content logical definition with the expansion * whether to include inactive concepts \n | |
| IN | date | 0..1 | dateTime | The date for which the expansion should be generated. if a date is provided, it means that the server should use the value set / code system definitions as they were on the given date, or return an error if this is not possible. Normally, the date is the current conditions (which is the default value) but under some circumstances, systems need to generate an expansion as it would have been in the past. A typical example of this would be where code selection is constrained to the set of codes that were available when the patient was treated, not when the record is being edited. Note that which date is appropriate is a matter for implementation policy. \n | |
| IN | offset | 0..1 | integer | Paging support - where to start if a subset is desired (default = 0). Offset is number of records (not number of pages) \n | |
| IN | count | 0..1 | integer | Paging support - how many codes should be provided in a partial page view. Paging only applies to flat expansions - servers ignore paging if the expansion is not flat. If count = 0, the client is asking how large the expansion is. Servers SHOULD honor this request for hierarchical expansions as well, and simply return the overall count \n | |
| IN | includeDesignations | 0..1 | boolean | Controls whether concept designations are to be included or excluded in value set expansions. Overrides the value in the expansion profile if there is one \n | |
| IN | includeDefinition | 0..1 | boolean | Controls whether the value set definition is included or excluded in value set expansions. Overrides the value in the expansion profile if there is one \n | |
| IN | activeOnly | 0..1 | boolean | Controls whether inactive concepts are included or excluded in value set expansions. Overrides the value in the expansion profile if there is one. Note that if the value set explicitly specifies that inactive codes are included, this parameter can still remove them from a specific expansion, but this parameter cannot include them if the value set excludes them \n | |
| IN | excludeNested | 0..1 | boolean | Controls whether or not the value set expansion nests codes or not (i.e. ValueSet.expansion.contains.contains). Overrides the value in the expansion profile if there is one \n | |
| IN | excludeNotForUI | 0..1 | boolean | Controls whether or not the value set expansion includes codes which cannot be displayed in user interfaces. Overrides the value in the expansion profile if there is one \n | |
| IN | excludePostCoordinated | 0..1 | boolean | Controls whether or not the value set expansion includes post coordinated codes. Overrides the value in the expansion profile if there is one \n | |
| IN | displayLanguage | 0..1 | code | Specifies the language to be used for description in the expansions i.e. the language to be used for ValueSet.expansion.contains.display. Overrides the value in the expansion profile if there is one \n | |
| IN | limitedExpansion | 0..1 | boolean | If the value set being expanded is incomplete (because it is too big to expand), return a limited expansion (a subset) with an indicator that expansion is incomplete. Overrides the value in the expansion profile if there is one \n | |
| OUT | return | 1..1 | ValueSet | The result of the expansion \n |
The value set expansion returned by this query should be treated as a transient result that will change over time (whether it does or not depends on how the value set is specified), so applications should repeat the operation each time the value set is used.
If the expansion is too large (at the discretion of the server), the server will return an error (OperationOutcome with code too-costly). Clients can work through large flat expansions in a set of pages (partial views of the full expansion) instead of just getting the full expansion in a single exchange by using offset and count parameters. Servers are not obliged to support paging, but if they do, SHALL support both the offset and count parameters. Hierarchical expansions are not subject to paging and servers simply return the entire expansion.
Different servers may return different results from expanding a value set for the following reasons:
When a server cannot correctly expand a value set because it does not fully understand the code systems (e.g. it has the wrong version, or incomplete definitions) then it SHALL return an error. If the value set itself is unbounded due to the inclusion of post-coordinated value sets (e.g. SNOMED CT, UCUM), then the extension http://hl7.org/fhir/StructureDefinition/valueset-unclosed can be used to indicate that the expansion is incomplete
\nOPERATION: Value Set based Validation
The official URL for this operation definition is:
http://hl7.org/fhir/OperationDefinition/ValueSet-validate-code
Validate that a coded value is in the set of codes allowed by a value set. If the operation is not called at the instance level, one of the in parameters "identifier" or "valueset" must be provided. One (and only one) of the in parameters (code, coding, codeableConcept) must be provided. The operation returns a result (true / false), an error message, and the recommended display for the code
\nURL: [base]/ValueSet/$validate-code
URL: [base]/ValueSet/[id]/$validate-code
Parameters
| Use | Name | Cardinality | Type | Binding | Documentation |
| IN | url | 0..1 | uri | Value set Canonical URL. The server must know the value set (e.g. it is defined explicitly in the server's value sets, or it is defined implicitly by some code system known to the server \n | |
| IN | context | 0..1 | uri | The context of the value set, so that the server can resolve this to a value set to validate against. The recommended format for this URI is [Structure Definition URL]#[name or path into structure definition] e.g. http://hl7.org/fhir/StructureDefinition/observation-hspc-height-hspcheight#Observation.interpretation. Other forms may be used but are not defined. This form is only usable if the terminology server also has access to the profile registry that the server is using, but can be used to delegate the mapping from an application context to a binding at run-time \n | |
| IN | valueSet | 0..1 | ValueSet | The value set is provided directly as part of the request. Servers may choose not to accept value sets in this fashion. This parameter is used when the client wants the server to expand a value set that is not stored on the server \n | |
| IN | code | 0..1 | code | The code that is to be validated. If a code is provided, a system must be provided \n | |
| IN | system | 0..1 | uri | The system for the code that is to be validated \n | |
| IN | version | 0..1 | string | The version of the system, if one was provided in the source data \n | |
| IN | display | 0..1 | string | The display associated with the code, if provided. If a display is provided a code must be provided. If no display is provided, the server cannot validate the display value, but may choose to return a recommended display name in an extension in the outcome. Whether displays are case sensitive is code system dependent \n | |
| IN | coding | 0..1 | Coding | A coding to validate \n | |
| IN | codeableConcept | 0..1 | CodeableConcept | A full codeableConcept to validate. The server returns true if one of the coding values is in the value set, and may also validate that the codings are not in conflict with each other if more than one is present \n | |
| IN | date | 0..1 | dateTime | The date for which the validation should be checked. Normally, this is the current conditions (which is the default values) but under some circumstances, systems need to validate that a correct code was used at some point in the past. A typical example of this would be where code selection is constrained to the set of codes that were available when the patient was treated, not when the record is being edited. Note that which date is appropriate is a matter for implementation policy. \n | |
| IN | abstract | 0..1 | boolean | if true, then an abstract code is allowed to be used in the context of the code that is being validated. Typically, abstract codes are allowed to be used in value set specifications (e.g. any code that is subsumed by an abstract code). If false (which is the default value), then only concrete codes as defined by the value set are allowed \n | |
| IN | displayLanguage | 0..1 | code | Specifies the language to be used for description when validating the display property \n | |
| OUT | result | 1..1 | boolean | True if the concept details supplied are valid \n | |
| OUT | message | 0..1 | string | Error details, if result = false. If this is provided when result = true, the message carries hints and warnings \n | |
| OUT | display | 0..1 | string | A valid display for the concept if the system wishes to display this to a user \n |
| Name | Flags | Card. | Type | Description & Constraints![\"doco\"](\"help16.png\") |
|---|---|---|---|---|
| n/a | Base Resource | |||
| Σ | 0..1 | id | Logical id of this artifact | |
| Σ | 0..1 | Meta | Metadata about the resource | |
| ?!Σ | 0..1 | uri | A set of rules under which this content was created | |
| 0..1 | code | Language of the resource content Common Languages (Extensible but limited to All Languages) | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Tracks balance, charges, for patient or cost center Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | Account number | |
| ?!Σ | 0..1 | code | active | inactive | entered-in-error AccountStatus (Required) | |
| Σ | 0..1 | CodeableConcept | E.g. patient, expense, depreciation Account Types (Example) | |
| Σ | 0..1 | string | Human-readable label | |
| Σ | 0..1 | Reference(Patient | Device | Practitioner | Location | HealthcareService | Organization) | What is account tied to? | |
| Σ | 0..1 | Period | Transaction window | |
| Σ | 0..1 | Period | Time window that transactions may be posted to this account | |
| 0..1 | Money | How much is in account? | ||
| Σ | 0..* | BackboneElement | The party(s) that are responsible for covering the payment of this account, and what order should they be applied to the account | |
| Σ | 1..1 | Reference(Coverage) | The party(s) that are responsible for covering the payment of this account | |
| Σ | 0..1 | positiveInt | The priority of the coverage in the context of this account | |
| Σ | 0..1 | Reference(Organization) | Who is responsible? | |
| Σ | 0..1 | string | Explanation of purpose/use | |
| 0..* | BackboneElement | Responsible for the account | ||
| 1..1 | Reference(Patient | RelatedPerson | Organization) | Responsible entity | ||
| 0..1 | boolean | Credit or other hold applied | ||
| 0..1 | Period | Guarrantee account during | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | The definition of a specific activity to be taken, independent of any particular patient or context Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | uri | Logical URI to reference this activity definition (globally unique) | |
| Σ | 0..* | Identifier | Additional identifier for the activity definition | |
| Σ | 0..1 | string | Business version of the activity definition | |
| Σ | 0..1 | string | Name for this activity definition (computer friendly) | |
| Σ | 0..1 | string | Name for this activity definition (human friendly) | |
| ?!Σ | 1..1 | code | draft | active | retired | unknown PublicationStatus (Required) | |
| ?!Σ | 0..1 | boolean | For testing purposes, not real usage | |
| Σ | 0..1 | dateTime | Date this was last changed | |
| Σ | 0..1 | string | Name of the publisher (organization or individual) | |
| Σ | 0..1 | markdown | Natural language description of the activity definition | |
| 0..1 | markdown | Why this activity definition is defined | ||
| 0..1 | string | Describes the clinical usage of the asset | ||
| 0..1 | date | When the activity definition was approved by publisher | ||
| 0..1 | date | When the activity definition was last reviewed | ||
| Σ | 0..1 | Period | When the activity definition is expected to be used | |
| Σ | 0..* | UsageContext | Context the content is intended to support | |
| Σ | 0..* | CodeableConcept | Intended jurisdiction for activity definition (if applicable) Jurisdiction ValueSet (Extensible) | |
| 0..* | CodeableConcept | E.g. Education, Treatment, Assessment, etc DefinitionTopic (Example) | ||
| 0..* | Contributor | A content contributor | ||
| Σ | 0..* | ContactDetail | Contact details for the publisher | |
| 0..1 | markdown | Use and/or publishing restrictions | ||
| 0..* | RelatedArtifact | Additional documentation, citations, etc | ||
| 0..* | Reference(Library) | Logic used by the asset | ||
| 0..1 | code | Kind of resource ResourceType (Required) | ||
| 0..1 | CodeableConcept | Detail type of activity Procedure Codes (SNOMED CT) (Example) | ||
| 0..1 | When activity is to occur | |||
| Timing | ||||
| dateTime | ||||
| Period | ||||
| Range | ||||
| 0..1 | Reference(Location) | Where it should happen | ||
| 0..* | BackboneElement | Who should participate in the action | ||
| 1..1 | code | patient | practitioner | related-person ActionParticipantType (Required) | ||
| 0..1 | CodeableConcept | E.g. Nurse, Surgeon, Parent, etc ActionParticipantRole (Example) | ||
| 0..1 | What's administered/supplied SNOMED CT Medication Codes (Example) | |||
| Reference(Medication | Substance) | ||||
| CodeableConcept | ||||
| 0..1 | SimpleQuantity | How much is administered/consumed/supplied | ||
| 0..* | Dosage | Detailed dosage instructions | ||
| 0..* | CodeableConcept | What part of body to perform on SNOMED CT Body Structures (Example) | ||
| 0..1 | Reference(StructureMap) | Transform to apply the template | ||
| 0..* | BackboneElement | Dynamic aspects of the definition | ||
| 0..1 | string | Natural language description of the dynamic value | ||
| 0..1 | string | The path to the element to be set dynamically | ||
| 0..1 | string | Language of the expression | ||
| 0..1 | string | An expression that provides the dynamic value for the customization | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| Σ | DomainResource | Medical care, research study or other healthcare event causing physical injury Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..1 | Identifier | Business identifier for the event | |
| Σ | 0..1 | code | AE | PAE \rAn adverse event is an event that caused harm to a patient, an adverse reaction is a something that is a subject-specific event that is a result of an exposure to a medication, food, device or environmental substance, a potential adverse event is something that occurred and that could have caused harm to a patient but did not AdverseEventCategory (Required) | |
| Σ | 0..1 | CodeableConcept | actual | potential SNOMED CT Clinical Findings (Example) | |
| Σ | 0..1 | Reference(Patient | ResearchSubject | Medication | Device) | Subject or group impacted by event | |
| Σ | 0..1 | dateTime | When the event occurred | |
| Σ | 0..* | Reference(Condition) | Adverse Reaction Events linked to exposure to substance | |
| Σ | 0..1 | Reference(Location) | Location where adverse event occurred | |
| Σ | 0..1 | CodeableConcept | Mild | Moderate | Severe AdverseEventSeriousness (Example) | |
| Σ | 0..1 | CodeableConcept | resolved | recovering | ongoing | resolvedWithSequelae | fatal | unknown AdverseEventOutcome (Required) | |
| Σ | 0..1 | Reference(Patient | Practitioner | RelatedPerson) | Who recorded the adverse event | |
| Σ | 0..1 | Reference(Practitioner | Device) | Who was involved in the adverse event or the potential adverse event | |
| Σ | 0..1 | string | Description of the adverse event | |
| Σ | 0..* | BackboneElement | The suspected agent causing the adverse event | |
| Σ | 1..1 | Reference(Substance | Medication | MedicationAdministration | MedicationStatement | Device) | Refers to the specific entity that caused the adverse event | |
| Σ | 0..1 | code | causality1 | causality2 AdverseEventCausality (Required) | |
| Σ | 0..1 | CodeableConcept | assess1 | assess2 AdverseEventCausalityAssessment (Example) | |
| Σ | 0..1 | string | AdverseEvent.suspectEntity.causalityProductRelatedness | |
| Σ | 0..1 | CodeableConcept | method1 | method2 AdverseEventCausalityMethod (Example) | |
| Σ | 0..1 | Reference(Practitioner | PractitionerRole) | AdverseEvent.suspectEntity.causalityAuthor | |
| Σ | 0..1 | CodeableConcept | result1 | result2 AdverseEventCausalityResult (Example) | |
| Σ | 0..* | Reference(Condition | Observation | AllergyIntolerance | FamilyMemberHistory | Immunization | Procedure) | AdverseEvent.subjectMedicalHistory | |
| Σ | 0..* | Reference(DocumentReference) | AdverseEvent.referenceDocument | |
| Σ | 0..* | Reference(ResearchStudy) | AdverseEvent.study | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | Allergy or Intolerance (generally: Risk of adverse reaction to a substance) + AllergyIntolerance.clinicalStatus SHALL be present if verificationStatus is not entered-in-error. + AllergyIntolerance.clinicalStatus SHALL NOT be present if verification Status is entered-in-error Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..* | Identifier | External ids for this item | |
| ?!ΣI | 0..1 | code | active | inactive | resolved AllergyIntoleranceClinicalStatus (Required) | |
| ?!ΣI | 1..1 | code | unconfirmed | confirmed | refuted | entered-in-error AllergyIntoleranceVerificationStatus (Required) | |
| Σ | 0..1 | code | allergy | intolerance - Underlying mechanism (if known) AllergyIntoleranceType (Required) | |
| Σ | 0..* | code | food | medication | environment | biologic AllergyIntoleranceCategory (Required) | |
| Σ | 0..1 | code | low | high | unable-to-assess AllergyIntoleranceCriticality (Required) | |
| Σ | 0..1 | CodeableConcept | Code that identifies the allergy or intolerance AllergyIntolerance Substance/Product, Condition and Negation Codes (Example) | |
| Σ | 1..1 | Reference(Patient) | Who the sensitivity is for | |
| 0..1 | When allergy or intolerance was identified | |||
| dateTime | ||||
| Age | ||||
| Period | ||||
| Range | ||||
| string | ||||
| 0..1 | dateTime | Date record was believed accurate | ||
| 0..1 | Reference(Practitioner | Patient) | Who recorded the sensitivity | ||
| Σ | 0..1 | Reference(Patient | RelatedPerson | Practitioner) | Source of the information about the allergy | |
| 0..1 | dateTime | Date(/time) of last known occurrence of a reaction | ||
| 0..* | Annotation | Additional text not captured in other fields | ||
| 0..* | BackboneElement | Adverse Reaction Events linked to exposure to substance | ||
| 0..1 | CodeableConcept | Specific substance or pharmaceutical product considered to be responsible for event Substance Code (Example) | ||
| 1..* | CodeableConcept | Clinical symptoms/signs associated with the Event SNOMED CT Clinical Findings (Example) | ||
| 0..1 | string | Description of the event as a whole | ||
| 0..1 | dateTime | Date(/time) when manifestations showed | ||
| 0..1 | code | mild | moderate | severe (of event as a whole) AllergyIntoleranceSeverity (Required) | ||
| 0..1 | CodeableConcept | How the subject was exposed to the substance SNOMED CT Route Codes (Example) | ||
| 0..* | Annotation | Text about event not captured in other fields | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s) + Only proposed or cancelled appointments can be missing start/end dates + Either start and end are specified, or neither Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..* | Identifier | External Ids for this item | |
| ?!Σ | 1..1 | code | proposed | pending | booked | arrived | fulfilled | cancelled | noshow | entered-in-error AppointmentStatus (Required) | |
| Σ | 0..1 | CodeableConcept | A broad categorisation of the service that is to be performed during this appointment ServiceCategory (Example) | |
| Σ | 0..* | CodeableConcept | The specific service that is to be performed during this appointment ServiceType (Example) | |
| Σ | 0..* | CodeableConcept | The specialty of a practitioner that would be required to perform the service requested in this appointment Practice Setting Code Value Set (Preferred) | |
| Σ | 0..1 | CodeableConcept | The style of appointment or patient that has been booked in the slot (not service type) v2 Appointment reason codes (Preferred) | |
| Σ | 0..* | CodeableConcept | Reason this appointment is scheduled Encounter Reason Codes (Preferred) | |
| 0..* | Reference(Condition | Procedure) | Reason the appointment is to takes place (resource) | ||
| 0..1 | unsignedInt | Used to make informed decisions if needing to re-prioritize | ||
| 0..1 | string | Shown on a subject line in a meeting request, or appointment list | ||
| 0..* | Reference(Any) | Additional information to support the appointment | ||
| Σ | 0..1 | instant | When appointment is to take place | |
| Σ | 0..1 | instant | When appointment is to conclude | |
| 0..1 | positiveInt | Can be less than start/end (e.g. estimate) | ||
| 0..* | Reference(Slot) | The slots that this appointment is filling | ||
| 0..1 | dateTime | The date that this appointment was initially created | ||
| 0..1 | string | Additional comments | ||
| 0..* | Reference(ReferralRequest) | The ReferralRequest provided as information to allocate to the Encounter | ||
| I | 1..* | BackboneElement | Participants involved in appointment + Either the type or actor on the participant SHALL be specified | |
| Σ | 0..* | CodeableConcept | Role of participant in the appointment ParticipantType (Extensible) | |
| Σ | 0..1 | Reference(Patient | Practitioner | RelatedPerson | Device | HealthcareService | Location) | Person, Location/HealthcareService or Device | |
| Σ | 0..1 | code | required | optional | information-only ParticipantRequired (Required) | |
| 1..1 | code | accepted | declined | tentative | needs-action ParticipationStatus (Required) | ||
| 0..* | Period | Potential date/time interval(s) requested to allocate the appointment within | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection + Either the participantType or actor must be specified Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..* | Identifier | External Ids for this item | |
| Σ | 1..1 | Reference(Appointment) | Appointment this response relates to | |
| 0..1 | instant | Time from appointment, or requested new start time | ||
| 0..1 | instant | Time from appointment, or requested new end time | ||
| Σ | 0..* | CodeableConcept | Role of participant in the appointment ParticipantType (Extensible) | |
| Σ | 0..1 | Reference(Patient | Practitioner | RelatedPerson | Device | HealthcareService | Location) | Person, Location/HealthcareService or Device | |
| ?!Σ | 1..1 | code | accepted | declined | tentative | in-process | completed | needs-action | entered-in-error ParticipationStatus (Required) | |
| 0..1 | string | Additional comments | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Event record kept for security purposes Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 1..1 | Coding | Type/identifier of event Audit Event ID (Extensible) | |
| Σ | 0..* | Coding | More specific type/id for the event Audit Event Sub-Type (Extensible) | |
| Σ | 0..1 | code | Type of action performed during the event AuditEventAction (Required) | |
| Σ | 1..1 | instant | Time when the event occurred on source | |
| Σ | 0..1 | code | Whether the event succeeded or failed AuditEventOutcome (Required) | |
| Σ | 0..1 | string | Description of the event outcome | |
| Σ | 0..* | CodeableConcept | The purposeOfUse of the event PurposeOfUse (Extensible) | |
| 1..* | BackboneElement | Actor involved in the event | ||
| 0..* | CodeableConcept | Agent role in the event SecurityRoleType (Extensible) | ||
| Σ | 0..1 | Reference(Practitioner | Organization | Device | Patient | RelatedPerson) | Direct reference to resource | |
| Σ | 0..1 | Identifier | Unique identifier for the user | |
| 0..1 | string | Alternative User id e.g. authentication | ||
| 0..1 | string | Human-meaningful name for the agent | ||
| 1..1 | boolean | Whether user is initiator | ||
| 0..1 | Reference(Location) | Where | ||
| 0..* | uri | Policy that authorized event | ||
| 0..1 | Coding | Type of media Media Type Code (Extensible) | ||
| 0..1 | BackboneElement | Logical network location for application activity | ||
| 0..1 | string | Identifier for the network access point of the user device | ||
| 0..1 | code | The type of network access point AuditEventAgentNetworkType (Required) | ||
| 0..* | CodeableConcept | Reason given for this user PurposeOfUse (Extensible) | ||
| 1..1 | BackboneElement | Audit Event Reporter | ||
| 0..1 | string | Logical source location within the enterprise | ||
| Σ | 1..1 | Identifier | The identity of source detecting the event | |
| 0..* | Coding | The type of source where event originated Audit Event Source Type (Extensible) | ||
| I | 0..* | BackboneElement | Data or objects used + Either a name or a query (NOT both) | |
| Σ | 0..1 | Identifier | Specific instance of object | |
| Σ | 0..1 | Reference(Any) | Specific instance of resource | |
| 0..1 | Coding | Type of entity involved AuditEventEntityType (Extensible) | ||
| 0..1 | Coding | What role the entity played AuditEventEntityRole (Extensible) | ||
| 0..1 | Coding | Life-cycle stage for the entity ObjectLifecycleEvents (Extensible) | ||
| 0..* | Coding | Security labels on the entity All Security Labels (Extensible) | ||
| ΣI | 0..1 | string | Descriptor for entity | |
| 0..1 | string | Descriptive text | ||
| ΣI | 0..1 | base64Binary | Query parameters | |
| 0..* | BackboneElement | Additional Information about the entity | ||
| 1..1 | string | Name of the property | ||
| 1..1 | base64Binary | Property value | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| Σ | DomainResource | Resource for non-supported content Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..* | Identifier | Business identifier | |
| ?!Σ | 1..1 | CodeableConcept | Kind of Resource Basic Resource Types (Example) | |
| Σ | 0..1 | Reference(Any) | Identifies the focus of this resource | |
| Σ | 0..1 | date | When created | |
| Σ | 0..1 | Reference(Practitioner | Patient | RelatedPerson) | Who created | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| Resource | Pure binary content defined by a format other than FHIR Elements defined in Ancestors: id, meta, implicitRules, language | |||
| Σ | 1..1 | code | MimeType of the binary content MimeType (Required) | |
| Σ | 0..1 | Reference(Any) | Access Control Management | |
| 1..1 | base64Binary | The actual content | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Specific and identified anatomical location Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | Bodysite identifier | |
| ?!Σ | 0..1 | boolean | Whether this body site record is in active use | |
| Σ | 0..1 | CodeableConcept | Named anatomical location SNOMED CT Body Structures (Example) | |
| 0..* | CodeableConcept | Modification to location code Bodysite Location Qualifier (Example) | ||
| Σ | 0..1 | string | Anatomical location description | |
| 0..* | Attachment | Attached images | ||
| Σ | 1..1 | Reference(Patient) | Who this is about | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| ΣI | Resource | Contains a collection of resources + FullUrl must be unique in a bundle, or else entries with the same fullUrl must have different meta.versionId + A document must have an identifier with a system and a value + entry.request only for some types of bundles + entry.response only for some types of bundles + total only when a search or history + entry.search only when a search Elements defined in Ancestors: id, meta, implicitRules, language | ||
| Σ | 0..1 | Identifier | Persistent identifier for the bundle | |
| Σ | 1..1 | code | document | message | transaction | transaction-response | batch | batch-response | history | searchset | collection BundleType (Required) | |
| ΣI | 0..1 | unsignedInt | If search, the total number of matches | |
| Σ | 0..* | BackboneElement | Links related to this Bundle | |
| Σ | 1..1 | string | See http://www.iana.org/assignments/link-relations/link-relations.xhtml#link-relations-1 | |
| Σ | 1..1 | uri | Reference details for the link | |
| ΣI | 0..* | BackboneElement | Entry in the bundle - will have a resource, or information + fullUrl cannot be a version specific reference + must be a resource unless there's a request or response | |
| Σ | 0..* | see link | Links related to this entry | |
| Σ | 0..1 | uri | Absolute URL for resource (server address, or UUID/OID) | |
| Σ | 0..1 | Resource | A resource in the bundle | |
| ΣI | 0..1 | BackboneElement | Search related information | |
| Σ | 0..1 | code | match | include | outcome - why this is in the result set SearchEntryMode (Required) | |
| Σ | 0..1 | decimal | Search ranking (between 0 and 1) | |
| ΣI | 0..1 | BackboneElement | Transaction Related Information | |
| Σ | 1..1 | code | GET | POST | PUT | DELETE HTTPVerb (Required) | |
| Σ | 1..1 | uri | URL for HTTP equivalent of this entry | |
| Σ | 0..1 | string | For managing cache currency | |
| Σ | 0..1 | instant | For managing update contention | |
| Σ | 0..1 | string | For managing update contention | |
| Σ | 0..1 | string | For conditional creates | |
| ΣI | 0..1 | BackboneElement | Transaction Related Information | |
| Σ | 1..1 | string | Status response code (text optional) | |
| Σ | 0..1 | uri | The location, if the operation returns a location | |
| Σ | 0..1 | string | The etag for the resource (if relevant) | |
| Σ | 0..1 | instant | Server's date time modified | |
| Σ | 0..1 | Resource | OperationOutcome with hints and warnings (for batch/transaction) | |
| Σ | 0..1 | Signature | Digital Signature | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | A statement of system capabilities + There can only be one REST declaration per mode. + The set of documents must be unique by the combination of profile and mode. + Capability Statements of kind 'instance' do not have implementation elements. + Messaging end-point is required (and is only permitted) when a statement is for an implementation. + Capability Statements of kind 'requirements' do not have software or implementation elements. + A Capability Statement SHALL have at least one of description, software, or implementation element. + A Capability Statement SHALL have at least one of REST, messaging or document element. Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..1 | uri | Logical URI to reference this capability statement (globally unique) | |
| Σ | 0..1 | string | Business version of the capability statement | |
| Σ | 0..1 | string | Name for this capability statement (computer friendly) | |
| Σ | 0..1 | string | Name for this capability statement (human friendly) | |
| ?!Σ | 1..1 | code | draft | active | retired | unknown PublicationStatus (Required) | |
| ?!Σ | 0..1 | boolean | For testing purposes, not real usage | |
| Σ | 1..1 | dateTime | Date this was last changed | |
| Σ | 0..1 | string | Name of the publisher (organization or individual) | |
| Σ | 0..* | ContactDetail | Contact details for the publisher | |
| I | 0..1 | markdown | Natural language description of the capability statement | |
| Σ | 0..* | UsageContext | Context the content is intended to support | |
| Σ | 0..* | CodeableConcept | Intended jurisdiction for capability statement (if applicable) Jurisdiction ValueSet (Extensible) | |
| 0..1 | markdown | Why this capability statement is defined | ||
| 0..1 | markdown | Use and/or publishing restrictions | ||
| Σ | 1..1 | code | instance | capability | requirements CapabilityStatementKind (Required) | |
| Σ | 0..* | uri | Canonical URL of another capability statement this implements | |
| ΣI | 0..1 | BackboneElement | Software that is covered by this capability statement | |
| Σ | 1..1 | string | A name the software is known by | |
| Σ | 0..1 | string | Version covered by this statement | |
| Σ | 0..1 | dateTime | Date this version released | |
| ΣI | 0..1 | BackboneElement | If this describes a specific instance | |
| Σ | 1..1 | string | Describes this specific instance | |
| Σ | 0..1 | uri | Base URL for the installation | |
| Σ | 1..1 | id | FHIR Version the system uses | |
| Σ | 1..1 | code | no | extensions | elements | both UnknownContentCode (Required) | |
| Σ | 1..* | code | formats supported (xml | json | ttl | mime type) MimeType (Required) | |
| Σ | 0..* | code | Patch formats supported MimeType (Required) | |
| Σ | 0..* | uri | Implementation guides supported | |
| Σ | 0..* | Reference(StructureDefinition) | Profiles for use cases supported | |
| ΣI | 0..* | BackboneElement | If the endpoint is a RESTful one + A given resource can only be described once per RESTful mode. | |
| Σ | 1..1 | code | client | server RestfulCapabilityMode (Required) | |
| 0..1 | string | General description of implementation | ||
| Σ | 0..1 | BackboneElement | Information about security of implementation | |
| Σ | 0..1 | boolean | Adds CORS Headers (http://enable-cors.org/) | |
| Σ | 0..* | CodeableConcept | OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates RestfulSecurityService (Extensible) | |
| 0..1 | string | General description of how security works | ||
| 0..* | BackboneElement | Certificates associated with security profiles | ||
| 0..1 | code | Mime type for certificates MimeType (Required) | ||
| 0..1 | base64Binary | Actual certificate | ||
| ΣI | 0..* | BackboneElement | Resource served on the REST interface + Search parameter names must be unique in the context of a resource. | |
| Σ | 1..1 | code | A resource type that is supported ResourceType (Required) | |
| Σ | 0..1 | Reference(StructureDefinition) | Base System profile for all uses of resource | |
| 0..1 | markdown | Additional information about the use of the resource type | ||
| 1..* | BackboneElement | What operations are supported? | ||
| 1..1 | code | read | vread | update | patch | delete | history-instance | history-type | create | search-type TypeRestfulInteraction (Required) | ||
| 0..1 | string | Anything special about operation behavior | ||
| 0..1 | code | no-version | versioned | versioned-update ResourceVersionPolicy (Required) | ||
| 0..1 | boolean | Whether vRead can return past versions | ||
| 0..1 | boolean | If update can commit to a new identity | ||
| 0..1 | boolean | If allows/uses conditional create | ||
| 0..1 | code | not-supported | modified-since | not-match | full-support ConditionalReadStatus (Required) | ||
| 0..1 | boolean | If allows/uses conditional update | ||
| 0..1 | code | not-supported | single | multiple - how conditional delete is supported ConditionalDeleteStatus (Required) | ||
| 0..* | code | literal | logical | resolves | enforced | local ReferenceHandlingPolicy (Required) | ||
| 0..* | string | _include values supported by the server | ||
| 0..* | string | _revinclude values supported by the server | ||
| 0..* | BackboneElement | Search parameters supported by implementation | ||
| 1..1 | string | Name of search parameter | ||
| 0..1 | uri | Source of definition for parameter | ||
| 1..1 | code | number | date | string | token | reference | composite | quantity | uri SearchParamType (Required) | ||
| 0..1 | string | Server-specific usage | ||
| 0..* | BackboneElement | What operations are supported? | ||
| 1..1 | code | transaction | batch | search-system | history-system SystemRestfulInteraction (Required) | ||
| 0..1 | string | Anything special about operation behavior | ||
| 0..* | see searchParam | Search parameters for searching all resources | ||
| Σ | 0..* | BackboneElement | Definition of an operation or a custom query | |
| 1..1 | string | Name by which the operation/query is invoked | ||
| Σ | 1..1 | Reference(OperationDefinition) | The defined operation/query | |
| 0..* | uri | Compartments served/used by system | ||
| ΣI | 0..* | BackboneElement | If messaging is supported + A Capability Statement messaging element SHALL have either supportedMessage or event element, but not both. | |
| 0..* | BackboneElement | Where messages should be sent | ||
| 1..1 | Coding | http | ftp | mllp + MessageTransport (Extensible) | ||
| 1..1 | uri | Network address or identifier of the end-point | ||
| 0..1 | unsignedInt | Reliable Message Cache Length (min) | ||
| 0..1 | string | Messaging interface behavior details | ||
| Σ | 0..* | BackboneElement | Messages supported by this system | |
| Σ | 1..1 | code | sender | receiver EventCapabilityMode (Required) | |
| Σ | 1..1 | Reference(MessageDefinition) | Message supported by this system | |
| Σ | 0..* | BackboneElement | Declare support for this event | |
| Σ | 1..1 | Coding | Event type MessageEvent (Example) | |
| 0..1 | code | Consequence | Currency | Notification MessageSignificanceCategory (Required) | ||
| 1..1 | code | sender | receiver EventCapabilityMode (Required) | ||
| 1..1 | code | Resource that's focus of message ResourceType (Required) | ||
| Σ | 1..1 | Reference(StructureDefinition) | Profile that describes the request | |
| Σ | 1..1 | Reference(StructureDefinition) | Profile that describes the response | |
| 0..1 | string | Endpoint-specific event documentation | ||
| ΣI | 0..* | BackboneElement | Document definition | |
| 1..1 | code | producer | consumer DocumentMode (Required) | ||
| 0..1 | string | Description of document support | ||
| Σ | 1..1 | Reference(StructureDefinition) | Constraint on a resource used in the document | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Healthcare plan for patient or group Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | External Ids for this plan | |
| Σ | 0..* | Reference(PlanDefinition | Questionnaire) | Protocol or definition | |
| Σ | 0..* | Reference(CarePlan) | Fulfills care plan | |
| Σ | 0..* | Reference(CarePlan) | CarePlan replaced by this CarePlan | |
| Σ | 0..* | Reference(CarePlan) | Part of referenced CarePlan | |
| ?!Σ | 1..1 | code | draft | active | suspended | completed | entered-in-error | cancelled | unknown CarePlanStatus (Required) | |
| ?!Σ | 1..1 | code | proposal | plan | order | option CarePlanIntent (Required) | |
| Σ | 0..* | CodeableConcept | Type of plan Care Plan Category (Example) | |
| Σ | 0..1 | string | Human-friendly name for the CarePlan | |
| Σ | 0..1 | string | Summary of nature of plan | |
| Σ | 1..1 | Reference(Patient | Group) | Who care plan is for | |
| Σ | 0..1 | Reference(Encounter | EpisodeOfCare) | Created in context of | |
| Σ | 0..1 | Period | Time period plan covers | |
| Σ | 0..* | Reference(Patient | Practitioner | RelatedPerson | Organization | CareTeam) | Who is responsible for contents of the plan | |
| 0..* | Reference(CareTeam) | Who's involved in plan? | ||
| Σ | 0..* | Reference(Condition) | Health issues this plan addresses | |
| 0..* | Reference(Any) | Information considered as part of plan | ||
| 0..* | Reference(Goal) | Desired outcome of plan | ||
| I | 0..* | BackboneElement | Action to occur as part of plan + Provide a reference or detail, not both | |
| 0..* | CodeableConcept | Results of the activity Care Plan Activity Outcome (Example) | ||
| 0..* | Reference(Any) | Appointment, Encounter, Procedure, etc. | ||
| 0..* | Annotation | Comments about the activity status/progress | ||
| I | 0..1 | Reference(Appointment | CommunicationRequest | DeviceRequest | MedicationRequest | NutritionOrder | Task | ProcedureRequest | ReferralRequest | VisionPrescription | RequestGroup) | Activity details defined in specific resource | |
| I | 0..1 | BackboneElement | In-line definition of activity | |
| 0..1 | CodeableConcept | diet | drug | encounter | observation | procedure | supply | other CarePlanActivityCategory (Example) | ||
| 0..1 | Reference(PlanDefinition | ActivityDefinition | Questionnaire) | Protocol or definition | ||
| 0..1 | CodeableConcept | Detail type of activity Care Plan Activity (Example) | ||
| 0..* | CodeableConcept | Why activity should be done or why activity was prohibited Activity Reason (Example) | ||
| 0..* | Reference(Condition) | Condition triggering need for activity | ||
| 0..* | Reference(Goal) | Goals this activity relates to | ||
| ?! | 1..1 | code | not-started | scheduled | in-progress | on-hold | completed | cancelled | unknown CarePlanActivityStatus (Required) | |
| 0..1 | string | Reason for current status | ||
| ?! | 0..1 | boolean | Do NOT do | |
| 0..1 | When activity is to occur | |||
| Timing | ||||
| Period | ||||
| string | ||||
| 0..1 | Reference(Location) | Where it should happen | ||
| 0..* | Reference(Practitioner | Organization | RelatedPerson | Patient | CareTeam) | Who will be responsible? | ||
| 0..1 | What is to be administered/supplied SNOMED CT Medication Codes (Example) | |||
| CodeableConcept | ||||
| Reference(Medication | Substance) | ||||
| 0..1 | SimpleQuantity | How to consume/day? | ||
| 0..1 | SimpleQuantity | How much to administer/supply/consume | ||
| 0..1 | string | Extra info describing activity to perform | ||
| 0..* | Annotation | Comments about the plan | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Planned participants in the coordination and delivery of care for a patient or group Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | External Ids for this team | |
| ?!Σ | 0..1 | code | proposed | active | suspended | inactive | entered-in-error CareTeamStatus (Required) | |
| Σ | 0..* | CodeableConcept | Type of team CareTeamCategory (Example) | |
| Σ | 0..1 | string | Name of the team, such as crisis assessment team | |
| Σ | 0..1 | Reference(Patient | Group) | Who care team is for | |
| Σ | 0..1 | Reference(Encounter | EpisodeOfCare) | Encounter or episode associated with CareTeam | |
| Σ | 0..1 | Period | Time period team covers | |
| I | 0..* | BackboneElement | Members of the team + CareTeam.participant.onBehalfOf can only be populated when CareTeam.participant.member is a Practitioner | |
| Σ | 0..1 | CodeableConcept | Type of involvement Participant Roles (Example) | |
| Σ | 0..1 | Reference(Practitioner | RelatedPerson | Patient | Organization | CareTeam) | Who is involved | |
| Σ | 0..1 | Reference(Organization) | Organization of the practitioner | |
| 0..1 | Period | Time period of participant | ||
| 0..* | CodeableConcept | Why the care team exists SNOMED CT Clinical Findings (Example) | ||
| 0..* | Reference(Condition) | Why the care team exists | ||
| Σ | 0..* | Reference(Organization) | Organization responsible for the care team | |
| 0..* | Annotation | Comments made about the CareTeam | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Item containing charge code(s) associated with the provision of healthcare provider products Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | Identifier | Business Identifier for item | |
| 0..* | uri | Defining information about the code of this charge item | ||
| ?!Σ | 1..1 | code | planned | billable | not-billable | aborted | billed | entered-in-error | unknown ChargeItemStatus (Required) | |
| 0..* | Reference(ChargeItem) | Part of referenced ChargeItem | ||
| Σ | 1..1 | CodeableConcept | A code that identifies the charge, like a billing code ChargeItemCode (Example) | |
| Σ | 1..1 | Reference(Patient | Group) | Individual service was done for/to | |
| Σ | 0..1 | Reference(Encounter | EpisodeOfCare) | Encounter / Episode associated with event | |
| Σ | 0..1 | When the charged service was applied | ||
| dateTime | ||||
| Period | ||||
| Timing | ||||
| 0..* | BackboneElement | Who performed charged service | ||
| 0..1 | CodeableConcept | What type of performance was done Procedure Performer Role Codes (Example) | ||
| 1..1 | Reference(Practitioner | Organization | Patient | Device | RelatedPerson) | Individual who was performing | ||
| 0..1 | Reference(Organization) | Organization providing the charged sevice | ||
| 0..1 | Reference(Organization) | Organization requesting the charged service | ||
| Σ | 0..1 | Quantity | Quantity of which the charge item has been serviced | |
| Σ | 0..* | CodeableConcept | Anatomical location, if relevant SNOMED CT Body Structures (Example) | |
| 0..1 | decimal | Factor overriding the associated rules | ||
| 0..1 | Money | Price overriding the associated rules | ||
| 0..1 | string | Reason for overriding the list price/factor | ||
| Σ | 0..1 | Reference(Practitioner | Organization | Patient | Device | RelatedPerson) | Individual who was entering | |
| Σ | 0..1 | dateTime | Date the charge item was entered | |
| 0..* | CodeableConcept | Why was the charged service rendered? ICD-10 Codes (Example) | ||
| 0..* | Reference(DiagnosticReport | ImagingStudy | Immunization | MedicationAdministration | MedicationDispense | Observation | Procedure | SupplyDelivery) | Which rendered service is being charged? | ||
| Σ | 0..* | Reference(Account) | Account to place this charge | |
| 0..* | Annotation | Comments made about the ChargeItem | ||
| 0..* | Reference(Any) | Further information supporting the this charge | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Claim, Pre-determination or Pre-authorization Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| 0..* | Identifier | Claim number | ||
| ?!Σ | 0..1 | code | active | cancelled | draft | entered-in-error Financial Resource Status Codes (Required) | |
| 0..1 | CodeableConcept | Type or discipline Example Claim Type Codes (Required) | ||
| 0..* | CodeableConcept | Finer grained claim type information Example Claim SubType Codes (Example) | ||
| 0..1 | code | complete | proposed | exploratory | other Use (Required) | ||
| 0..1 | Reference(Patient) | The subject of the Products and Services | ||
| 0..1 | Period | Period for charge submission | ||
| 0..1 | dateTime | Creation date | ||
| 0..1 | Reference(Practitioner) | Author | ||
| 0..1 | Reference(Organization) | Target | ||
| 0..1 | Reference(Practitioner) | Responsible provider | ||
| 0..1 | Reference(Organization) | Responsible organization | ||
| 0..1 | CodeableConcept | Desired processing priority Process Priority Codes (Example) | ||
| 0..1 | CodeableConcept | Funds requested to be reserved Funds Reservation Codes (Example) | ||
| 0..* | BackboneElement | Related Claims which may be revelant to processing this claimn | ||
| 0..1 | Reference(Claim) | Reference to the related claim | ||
| 0..1 | CodeableConcept | How the reference claim is related Example Related Claim Relationship Codes (Example) | ||
| 0..1 | Identifier | Related file or case reference | ||
| 0..1 | Reference(MedicationRequest | VisionPrescription) | Prescription authorizing services or products | ||
| 0..1 | Reference(MedicationRequest) | Original prescription if superceded by fulfiller | ||
| 0..1 | BackboneElement | Party to be paid any benefits payable | ||
| 1..1 | CodeableConcept | Type of party: Subscriber, Provider, other Claim Payee Type Codes (Example) | ||
| 0..1 | Coding | organization | patient | practitioner | relatedperson ClaimPayeeResourceType (Example) | ||
| 0..1 | Reference(Practitioner | Organization | Patient | RelatedPerson) | Party to receive the payable | ||
| 0..1 | Reference(ReferralRequest) | Treatment Referral | ||
| 0..1 | Reference(Location) | Servicing Facility | ||
| 0..* | BackboneElement | Members of the care team | ||
| 1..1 | positiveInt | Number to covey order of careTeam | ||
| 1..1 | Reference(Practitioner | Organization) | Provider individual or organization | ||
| 0..1 | boolean | Billing provider | ||
| 0..1 | CodeableConcept | Role on the team Claim Care Team Role Codes (Example) | ||
| 0..1 | CodeableConcept | Type, classification or Specialization Example Provider Qualification Codes (Example) | ||
| 0..* | BackboneElement | Exceptions, special considerations, the condition, situation, prior or concurrent issues | ||
| 1..1 | positiveInt | Information instance identifier | ||
| 1..1 | CodeableConcept | General class of information Claim Information Category Codes (Example) | ||
| 0..1 | CodeableConcept | Type of information Exception Codes (Example) | ||
| 0..1 | When it occurred | |||
| date | ||||
| Period | ||||
| 0..1 | Additional Data or supporting information | |||
| string | ||||
| Quantity | ||||
| Attachment | ||||
| Reference(Any) | ||||
| 0..1 | CodeableConcept | Reason associated with the information Missing Tooth Reason Codes (Example) | ||
| 0..* | BackboneElement | List of Diagnosis | ||
| 1..1 | positiveInt | Number to covey order of diagnosis | ||
| 1..1 | Patient's diagnosis ICD-10 Codes (Example) | |||
| CodeableConcept | ||||
| Reference(Condition) | ||||
| 0..* | CodeableConcept | Timing or nature of the diagnosis Example Diagnosis Type Codes (Example) | ||
| 0..1 | CodeableConcept | Package billing code Example Diagnosis Related Group Codes (Example) | ||
| 0..* | BackboneElement | Procedures performed | ||
| 1..1 | positiveInt | Procedure sequence for reference | ||
| 0..1 | dateTime | When the procedure was performed | ||
| 1..1 | Patient's list of procedures performed ICD-10 Procedure Codes (Example) | |||
| CodeableConcept | ||||
| Reference(Procedure) | ||||
| 0..* | BackboneElement | Insurance or medical plan | ||
| 1..1 | positiveInt | Service instance identifier | ||
| 1..1 | boolean | Is the focal Coverage | ||
| 1..1 | Reference(Coverage) | Insurance information | ||
| 0..1 | string | Business agreement | ||
| 0..* | string | Pre-Authorization/Determination Reference | ||
| 0..1 | Reference(ClaimResponse) | Adjudication results | ||
| 0..1 | BackboneElement | Details about an accident | ||
| 1..1 | date | When the accident occurred\nsee information codes\nsee information codes | ||
| 0..1 | CodeableConcept | The nature of the accident ActIncidentCode (Required) | ||
| 0..1 | Accident Place | |||
| Address | ||||
| Reference(Location) | ||||
| 0..1 | Period | Period unable to work | ||
| 0..1 | Period | Period in hospital | ||
| 0..* | BackboneElement | Goods and Services | ||
| 1..1 | positiveInt | Service instance | ||
| 0..* | positiveInt | Applicable careTeam members | ||
| 0..* | positiveInt | Applicable diagnoses | ||
| 0..* | positiveInt | Applicable procedures | ||
| 0..* | positiveInt | Applicable exception and supporting information | ||
| 0..1 | CodeableConcept | Revenue or cost center code Example Revenue Center Codes (Example) | ||
| 0..1 | CodeableConcept | Type of service or product Benefit SubCategory Codes (Example) | ||
| 0..1 | CodeableConcept | Billing Code USCLS Codes (Example) | ||
| 0..* | CodeableConcept | Service/Product billing modifiers Modifier type Codes (Example) | ||
| 0..* | CodeableConcept | Program specific reason for item inclusion Example Program Reason Codes (Example) | ||
| 0..1 | Date or dates of Service | |||
| date | ||||
| Period | ||||
| 0..1 | Place of service Example Service Place Codes (Example) | |||
| CodeableConcept | ||||
| Address | ||||
| Reference(Location) | ||||
| 0..1 | SimpleQuantity | Count of Products or Services | ||
| 0..1 | Money | Fee, charge or cost per point | ||
| 0..1 | decimal | Price scaling factor | ||
| 0..1 | Money | Total item cost | ||
| 0..* | Reference(Device) | Unique Device Identifier | ||
| 0..1 | CodeableConcept | Service Location Oral Site Codes (Example) | ||
| 0..* | CodeableConcept | Service Sub-location Surface Codes (Example) | ||
| 0..* | Reference(Encounter) | Encounters related to this billed item | ||
| 0..* | BackboneElement | Additional items | ||
| 1..1 | positiveInt | Service instance | ||
| 0..1 | CodeableConcept | Revenue or cost center code Example Revenue Center Codes (Example) | ||
| 0..1 | CodeableConcept | Type of service or product Benefit SubCategory Codes (Example) | ||
| 0..1 | CodeableConcept | Billing Code USCLS Codes (Example) | ||
| 0..* | CodeableConcept | Service/Product billing modifiers Modifier type Codes (Example) | ||
| 0..* | CodeableConcept | Program specific reason for item inclusion Example Program Reason Codes (Example) | ||
| 0..1 | SimpleQuantity | Count of Products or Services | ||
| 0..1 | Money | Fee, charge or cost per point | ||
| 0..1 | decimal | Price scaling factor | ||
| 0..1 | Money | Total additional item cost | ||
| 0..* | Reference(Device) | Unique Device Identifier | ||
| 0..* | BackboneElement | Additional items | ||
| 1..1 | positiveInt | Service instance | ||
| 0..1 | CodeableConcept | Revenue or cost center code Example Revenue Center Codes (Example) | ||
| 0..1 | CodeableConcept | Type of service or product Benefit SubCategory Codes (Example) | ||
| 0..1 | CodeableConcept | Billing Code USCLS Codes (Example) | ||
| 0..* | CodeableConcept | Service/Product billing modifiers Modifier type Codes (Example) | ||
| 0..* | CodeableConcept | Program specific reason for item inclusion Example Program Reason Codes (Example) | ||
| 0..1 | SimpleQuantity | Count of Products or Services | ||
| 0..1 | Money | Fee, charge or cost per point | ||
| 0..1 | decimal | Price scaling factor | ||
| 0..1 | Money | Net additional item cost | ||
| 0..* | Reference(Device) | Unique Device Identifier | ||
| 0..1 | Money | Total claim cost | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Remittance resource Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| 0..* | Identifier | Response number | ||
| ?!Σ | 0..1 | code | active | cancelled | draft | entered-in-error Financial Resource Status Codes (Required) | |
| 0..1 | Reference(Patient) | The subject of the Products and Services | ||
| 0..1 | dateTime | Creation date | ||
| 0..1 | Reference(Organization) | Insurance issuing organization | ||
| 0..1 | Reference(Practitioner) | Responsible practitioner | ||
| 0..1 | Reference(Organization) | Responsible organization | ||
| 0..1 | Reference(Claim) | Id of resource triggering adjudication | ||
| 0..1 | CodeableConcept | complete | error | partial Claim Processing Codes (Example) | ||
| 0..1 | string | Disposition Message | ||
| 0..1 | CodeableConcept | Party to be paid any benefits payable Claim Payee Type Codes (Example) | ||
| 0..* | BackboneElement | Line items | ||
| 1..1 | positiveInt | Service instance | ||
| 0..* | positiveInt | List of note numbers which apply | ||
| 0..* | BackboneElement | Adjudication details | ||
| 1..1 | CodeableConcept | Adjudication category such as co-pay, eligible, benefit, etc. Adjudication Value Codes (Example) | ||
| 0..1 | CodeableConcept | Explanation of Adjudication outcome Adjudication Reason Codes (Example) | ||
| 0..1 | Money | Monetary amount | ||
| 0..1 | decimal | Non-monetary value | ||
| 0..* | BackboneElement | Detail line items | ||
| 1..1 | positiveInt | Service instance | ||
| 0..* | positiveInt | List of note numbers which apply | ||
| 0..* | see adjudication | Detail level adjudication details | ||
| 0..* | BackboneElement | Subdetail line items | ||
| 1..1 | positiveInt | Service instance | ||
| 0..* | positiveInt | List of note numbers which apply | ||
| 0..* | see adjudication | Subdetail level adjudication details | ||
| 0..* | BackboneElement | Insurer added line items | ||
| 0..* | positiveInt | Service instances | ||
| 0..1 | CodeableConcept | Revenue or cost center code Example Revenue Center Codes (Example) | ||
| 0..1 | CodeableConcept | Type of service or product Benefit SubCategory Codes (Example) | ||
| 0..1 | CodeableConcept | Group, Service or Product USCLS Codes (Example) | ||
| 0..* | CodeableConcept | Service/Product billing modifiers Modifier type Codes (Example) | ||
| 0..1 | Money | Professional fee or Product charge | ||
| 0..* | positiveInt | List of note numbers which apply | ||
| 0..* | see adjudication | Added items adjudication | ||
| 0..* | BackboneElement | Added items details | ||
| 0..1 | CodeableConcept | Revenue or cost center code Example Revenue Center Codes (Example) | ||
| 0..1 | CodeableConcept | Type of service or product Benefit SubCategory Codes (Example) | ||
| 0..1 | CodeableConcept | Service or Product USCLS Codes (Example) | ||
| 0..* | CodeableConcept | Service/Product billing modifiers Modifier type Codes (Example) | ||
| 0..1 | Money | Professional fee or Product charge | ||
| 0..* | positiveInt | List of note numbers which apply | ||
| 0..* | see adjudication | Added items detail adjudication | ||
| 0..* | BackboneElement | Processing errors | ||
| 0..1 | positiveInt | Item sequence number | ||
| 0..1 | positiveInt | Detail sequence number | ||
| 0..1 | positiveInt | Subdetail sequence number | ||
| 1..1 | CodeableConcept | Error code detailing processing issues Adjudication Error Codes (Example) | ||
| 0..1 | Money | Total Cost of service from the Claim | ||
| 0..1 | Money | Unallocated deductible | ||
| 0..1 | Money | Total benefit payable for the Claim | ||
| 0..1 | BackboneElement | Payment details, if paid | ||
| 0..1 | CodeableConcept | Partial or Complete Example Payment Type Codes (Example) | ||
| 0..1 | Money | Payment adjustment for non-Claim issues | ||
| 0..1 | CodeableConcept | Explanation for the non-claim adjustment Payment Adjustment Reason Codes (Example) | ||
| 0..1 | date | Expected data of Payment | ||
| 0..1 | Money | Payable amount after adjustment | ||
| 0..1 | Identifier | Identifier of the payment instrument | ||
| 0..1 | Coding | Funds reserved status Funds Reservation Codes (Example) | ||
| 0..1 | CodeableConcept | Printed Form Identifier Form Codes (Example) | ||
| 0..* | BackboneElement | Processing notes | ||
| 0..1 | positiveInt | Sequence Number for this note | ||
| 0..1 | CodeableConcept | display | print | printoper NoteType (Required) | ||
| 0..1 | string | Note explanatory text | ||
| 0..1 | CodeableConcept | Language if different from the resource Common Languages (Extensible but limited to All Languages) | ||
| 0..* | Reference(CommunicationRequest) | Request for additional information | ||
| 0..* | BackboneElement | Insurance or medical plan | ||
| 1..1 | positiveInt | Service instance identifier | ||
| 1..1 | boolean | Is the focal Coverage | ||
| 1..1 | Reference(Coverage) | Insurance information | ||
| 0..1 | string | Business agreement | ||
| 0..* | string | Pre-Authorization/Determination Reference | ||
| 0..1 | Reference(ClaimResponse) | Adjudication results | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | A clinical assessment performed when planning treatments and management strategies for a patient Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | Business identifier | |
| ?!Σ | 1..1 | code | draft | completed | entered-in-error ClinicalImpressionStatus (Required) | |
| Σ | 0..1 | CodeableConcept | Kind of assessment performed | |
| Σ | 0..1 | string | Why/how the assessment was performed | |
| Σ | 1..1 | Reference(Patient | Group) | Patient or group assessed | |
| Σ | 0..1 | Reference(Encounter | EpisodeOfCare) | Encounter or Episode created from | |
| Σ | 0..1 | Time of assessment | ||
| dateTime | ||||
| Period | ||||
| Σ | 0..1 | dateTime | When the assessment was documented | |
| Σ | 0..1 | Reference(Practitioner) | The clinician performing the assessment | |
| 0..1 | Reference(ClinicalImpression) | Reference to last assessment | ||
| Σ | 0..* | Reference(Condition | AllergyIntolerance) | Relevant impressions of patient state | |
| 0..* | BackboneElement | One or more sets of investigations (signs, symptions, etc.) | ||
| 1..1 | CodeableConcept | A name/code for the set Investigation Type (Example) | ||
| 0..* | Reference(Observation | QuestionnaireResponse | FamilyMemberHistory | DiagnosticReport | RiskAssessment | ImagingStudy) | Record of a specific investigation | ||
| 0..* | uri | Clinical Protocol followed | ||
| 0..1 | string | Summary of the assessment | ||
| 0..* | BackboneElement | Possible or likely findings and diagnoses | ||
| 1..1 | What was found Condition/Problem/Diagnosis Codes (Example) | |||
| CodeableConcept | ||||
| Reference(Condition | Observation) | ||||
| 0..1 | string | Which investigations support finding | ||
| 0..* | CodeableConcept | Estimate of likely outcome Clinical Impression Prognosis (Example) | ||
| 0..* | Reference(RiskAssessment) | RiskAssessment expressing likely outcome | ||
| 0..* | Reference(ReferralRequest | ProcedureRequest | Procedure | MedicationRequest | Appointment) | Action taken as part of assessment procedure | ||
| 0..* | Annotation | Comments made about the ClinicalImpression | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | A set of codes drawn from one or more code systems + Within a code system definition, all the codes SHALL be unique Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..1 | uri | Logical URI to reference this code system (globally unique) (Coding.system) | |
| Σ | 0..1 | Identifier | Additional identifier for the code system | |
| Σ | 0..1 | string | Business version of the code system (Coding.version) | |
| Σ | 0..1 | string | Name for this code system (computer friendly) | |
| Σ | 0..1 | string | Name for this code system (human friendly) | |
| ?!Σ | 1..1 | code | draft | active | retired | unknown PublicationStatus (Required) | |
| ?!Σ | 0..1 | boolean | For testing purposes, not real usage | |
| Σ | 0..1 | dateTime | Date this was last changed | |
| Σ | 0..1 | string | Name of the publisher (organization or individual) | |
| Σ | 0..* | ContactDetail | Contact details for the publisher | |
| 0..1 | markdown | Natural language description of the code system | ||
| Σ | 0..* | UsageContext | Context the content is intended to support | |
| Σ | 0..* | CodeableConcept | Intended jurisdiction for code system (if applicable) Jurisdiction ValueSet (Extensible) | |
| 0..1 | markdown | Why this code system is defined | ||
| 0..1 | markdown | Use and/or publishing restrictions | ||
| Σ | 0..1 | boolean | If code comparison is case sensitive | |
| Σ | 0..1 | uri | Canonical URL for value set with entire code system | |
| Σ | 0..1 | code | grouped-by | is-a | part-of | classified-with CodeSystemHierarchyMeaning (Required) | |
| Σ | 0..1 | boolean | If code system defines a post-composition grammar | |
| Σ | 0..1 | boolean | If definitions are not stable | |
| Σ | 1..1 | code | not-present | example | fragment | complete CodeSystemContentMode (Required) | |
| Σ | 0..1 | unsignedInt | Total concepts in the code system | |
| Σ | 0..* | BackboneElement | Filter that can be used in a value set | |
| Σ | 1..1 | code | Code that identifies the filter | |
| Σ | 0..1 | string | How or why the filter is used | |
| Σ | 1..* | code | Operators that can be used with filter FilterOperator (Required) | |
| Σ | 1..1 | string | What to use for the value | |
| Σ | 0..* | BackboneElement | Additional information supplied about each concept | |
| Σ | 1..1 | code | Identifies the property on the concepts, and when referred to in operations | |
| Σ | 0..1 | uri | Formal identifier for the property | |
| Σ | 0..1 | string | Why the property is defined, and/or what it conveys | |
| Σ | 1..1 | code | code | Coding | string | integer | boolean | dateTime PropertyType (Required) | |
| 0..* | BackboneElement | Concepts in the code system | ||
| 1..1 | code | Code that identifies concept | ||
| 0..1 | string | Text to display to the user | ||
| 0..1 | string | Formal definition | ||
| 0..* | BackboneElement | Additional representations for the concept | ||
| 0..1 | code | Human language of the designation Common Languages (Extensible but limited to All Languages) | ||
| 0..1 | Coding | Details how this designation would be used Designation Use (Extensible) | ||
| 1..1 | string | The text value for this designation | ||
| 0..* | BackboneElement | Property value for the concept | ||
| 1..1 | code | Reference to CodeSystem.property.code | ||
| 1..1 | Value of the property for this concept | |||
| code | ||||
| Coding | ||||
| string | ||||
| integer | ||||
| boolean | ||||
| dateTime | ||||
| 0..* | see concept | Child Concepts (is-a/contains/categorizes) | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | A record of information transmitted from a sender to a receiver + Not Done Reason can only be specified if NotDone is "true" Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..* | Identifier | Unique identifier | |
| Σ | 0..* | Reference(PlanDefinition | ActivityDefinition) | Instantiates protocol or definition | |
| Σ | 0..* | Reference(Any) | Request fulfilled by this communication | |
| Σ | 0..* | Reference(Any) | Part of this action | |
| ?!Σ | 1..1 | code | preparation | in-progress | suspended | aborted | completed | entered-in-error EventStatus (Required) | |
| ?!Σ | 0..1 | boolean | Communication did not occur | |
| ΣI | 0..1 | CodeableConcept | Why communication did not occur CommunicationNotDoneReason (Example) | |
| 0..* | CodeableConcept | Message category CommunicationCategory (Example) | ||
| 0..* | CodeableConcept | A channel of communication v3 Code System ParticipationMode (Example) | ||
| Σ | 0..1 | Reference(Patient | Group) | Focus of message | |
| 0..* | Reference(Device | Organization | Patient | Practitioner | RelatedPerson | Group) | Message recipient | ||
| 0..* | Reference(Any) | Focal resources | ||
| Σ | 0..1 | Reference(Encounter | EpisodeOfCare) | Encounter or episode leading to message | |
| 0..1 | dateTime | When sent | ||
| 0..1 | dateTime | When received | ||
| 0..1 | Reference(Device | Organization | Patient | Practitioner | RelatedPerson) | Message sender | ||
| Σ | 0..* | CodeableConcept | Indication for message SNOMED CT Clinical Findings (Example) | |
| Σ | 0..* | Reference(Condition | Observation) | Why was communication done? | |
| 0..* | BackboneElement | Message payload | ||
| 1..1 | Message part content | |||
| string | ||||
| Attachment | ||||
| Reference(Any) | ||||
| 0..* | Annotation | Comments made about the communication | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | A request for information to be sent to a receiver Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | Unique identifier | |
| Σ | 0..* | Reference(Any) | Fulfills plan or proposal | |
| Σ | 0..* | Reference(CommunicationRequest) | Request(s) replaced by this request | |
| Σ | 0..1 | Identifier | Composite request this is part of | |
| ?!Σ | 1..1 | code | draft | active | suspended | cancelled | completed | entered-in-error | unknown RequestStatus (Required) | |
| 0..* | CodeableConcept | Message category CommunicationCategory (Example) | ||
| Σ | 0..1 | code | Message urgency RequestPriority (Required) | |
| 0..* | CodeableConcept | A channel of communication v3 Code System ParticipationMode (Example) | ||
| 0..1 | Reference(Patient | Group) | Focus of message | ||
| 0..* | Reference(Device | Organization | Patient | Practitioner | RelatedPerson | Group | CareTeam) | Message recipient | ||
| 0..* | Reference(Any) | Focal resources | ||
| Σ | 0..1 | Reference(Encounter | EpisodeOfCare) | Encounter or episode leading to message | |
| 0..* | BackboneElement | Message payload | ||
| 1..1 | Message part content | |||
| string | ||||
| Attachment | ||||
| Reference(Any) | ||||
| Σ | 0..1 | When scheduled | ||
| dateTime | ||||
| Period | ||||
| Σ | 0..1 | dateTime | When request transitioned to being actionable | |
| 0..1 | Reference(Device | Organization | Patient | Practitioner | RelatedPerson) | Message sender | ||
| ΣI | 0..1 | BackboneElement | Who/what is requesting service + onBehalfOf can only be specified if agent is practitioner or device | |
| Σ | 1..1 | Reference(Practitioner | Organization | Patient | RelatedPerson | Device) | Individual making the request | |
| ΣI | 0..1 | Reference(Organization) | Organization agent is acting for | |
| Σ | 0..* | CodeableConcept | Why is communication needed? v3 Code System ActReason (Example) | |
| Σ | 0..* | Reference(Condition | Observation) | Why is communication needed? | |
| 0..* | Annotation | Comments made about communication request | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Compartment Definition for a resource Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 1..1 | uri | Logical URI to reference this compartment definition (globally unique) | |
| Σ | 1..1 | string | Name for this compartment definition (computer friendly) | |
| Σ | 0..1 | string | Name for this compartment definition (human friendly) | |
| ?!Σ | 1..1 | code | draft | active | retired | unknown PublicationStatus (Required) | |
| ?!Σ | 0..1 | boolean | For testing purposes, not real usage | |
| Σ | 0..1 | dateTime | Date this was last changed | |
| Σ | 0..1 | string | Name of the publisher (organization or individual) | |
| Σ | 0..* | ContactDetail | Contact details for the publisher | |
| 0..1 | markdown | Natural language description of the compartment definition | ||
| 0..1 | markdown | Why this compartment definition is defined | ||
| Σ | 0..* | UsageContext | Context the content is intended to support | |
| Σ | 0..* | CodeableConcept | Intended jurisdiction for compartment definition (if applicable) Jurisdiction ValueSet (Extensible) | |
| Σ | 1..1 | code | Patient | Encounter | RelatedPerson | Practitioner | Device CompartmentType (Required) | |
| Σ | 1..1 | boolean | Whether the search syntax is supported | |
| Σ | 0..* | BackboneElement | How a resource is related to the compartment | |
| Σ | 1..1 | code | Name of resource type ResourceType (Required) | |
| Σ | 0..* | string | Search Parameter Name, or chained parameters | |
| 0..1 | string | Additional documentation about the resource and compartment | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | A set of resources composed into a single coherent clinical statement with clinical attestation Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | Identifier | Logical identifier of composition (version-independent) | |
| ?!Σ | 1..1 | code | preliminary | final | amended | entered-in-error CompositionStatus (Required) | |
| Σ | 1..1 | CodeableConcept | Kind of composition (LOINC if possible) FHIR Document Type Codes (Preferred) | |
| Σ | 0..1 | CodeableConcept | Categorization of Composition FHIR Document Class Codes (Example) | |
| Σ | 1..1 | Reference(Any) | Who and/or what the composition is about | |
| Σ | 0..1 | Reference(Encounter) | Context of the Composition | |
| Σ | 1..1 | dateTime | Composition editing time | |
| Σ | 1..* | Reference(Practitioner | Device | Patient | RelatedPerson) | Who and/or what authored the composition | |
| Σ | 1..1 | string | Human Readable name/title | |
| ?!Σ | 0..1 | code | As defined by affinity domain ConfidentialityClassification (Required) | |
| Σ | 0..* | BackboneElement | Attests to accuracy of composition | |
| Σ | 1..* | code | personal | professional | legal | official CompositionAttestationMode (Required) | |
| Σ | 0..1 | dateTime | When the composition was attested | |
| Σ | 0..1 | Reference(Patient | Practitioner | Organization) | Who attested the composition | |
| Σ | 0..1 | Reference(Organization) | Organization which maintains the composition | |
| Σ | 0..* | BackboneElement | Relationships to other compositions/documents | |
| Σ | 1..1 | code | replaces | transforms | signs | appends DocumentRelationshipType (Required) | |
| Σ | 1..1 | Target of the relationship | ||
| Identifier | ||||
| Reference(Composition) | ||||
| Σ | 0..* | BackboneElement | The clinical service(s) being documented | |
| Σ | 0..* | CodeableConcept | Code(s) that apply to the event being documented v3 Code System ActCode (Example) | |
| Σ | 0..1 | Period | The period covered by the documentation | |
| Σ | 0..* | Reference(Any) | The event(s) being documented | |
| I | 0..* | BackboneElement | Composition is broken into sections + A section must at least one of text, entries, or sub-sections + A section can only have an emptyReason if it is empty | |
| 0..1 | string | Label for section (e.g. for ToC) | ||
| 0..1 | CodeableConcept | Classification of section (recommended) Document Section Codes (Example) | ||
| I | 0..1 | Narrative | Text summary of the section, for human interpretation | |
| ?!Σ | 0..1 | code | working | snapshot | changes ListMode (Required) | |
| 0..1 | CodeableConcept | Order of section entries List Order Codes (Preferred) | ||
| I | 0..* | Reference(Any) | A reference to data that supports this section | |
| I | 0..1 | CodeableConcept | Why the section is empty List Empty Reasons (Preferred) | |
| I | 0..* | see section | Nested Section | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | A map from one set of concepts to one or more other concepts Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | uri | Logical URI to reference this concept map (globally unique) | |
| Σ | 0..1 | Identifier | Additional identifier for the concept map | |
| Σ | 0..1 | string | Business version of the concept map | |
| Σ | 0..1 | string | Name for this concept map (computer friendly) | |
| Σ | 0..1 | string | Name for this concept map (human friendly) | |
| ?!Σ | 1..1 | code | draft | active | retired | unknown PublicationStatus (Required) | |
| ?!Σ | 0..1 | boolean | For testing purposes, not real usage | |
| Σ | 0..1 | dateTime | Date this was last changed | |
| Σ | 0..1 | string | Name of the publisher (organization or individual) | |
| Σ | 0..* | ContactDetail | Contact details for the publisher | |
| 0..1 | markdown | Natural language description of the concept map | ||
| Σ | 0..* | UsageContext | Context the content is intended to support | |
| Σ | 0..* | CodeableConcept | Intended jurisdiction for concept map (if applicable) Jurisdiction ValueSet (Extensible) | |
| 0..1 | markdown | Why this concept map is defined | ||
| 0..1 | markdown | Use and/or publishing restrictions | ||
| Σ | 0..1 | Identifies the source of the concepts which are being mapped | ||
| uri | ||||
| Reference(ValueSet) | ||||
| Σ | 0..1 | Provides context to the mappings | ||
| uri | ||||
| Reference(ValueSet) | ||||
| 0..* | BackboneElement | Same source and target systems | ||
| 0..1 | uri | Code System (if value set crosses code systems) | ||
| 0..1 | string | Specific version of the code system | ||
| 0..1 | uri | System of the target (if necessary) | ||
| 0..1 | string | Specific version of the code system | ||
| 1..* | BackboneElement | Mappings for a concept from the source set | ||
| 0..1 | code | Identifies element being mapped | ||
| 0..1 | string | Display for the code | ||
| I | 0..* | BackboneElement | Concept in target system for element + If the map is narrower or inexact, there SHALL be some comments | |
| 0..1 | code | Code that identifies the target element | ||
| 0..1 | string | Display for the code | ||
| ?! | 0..1 | code | relatedto | equivalent | equal | wider | subsumes | narrower | specializes | inexact | unmatched | disjoint ConceptMapEquivalence (Required) | |
| I | 0..1 | string | Description of status/issues in mapping | |
| 0..* | BackboneElement | Other elements required for this mapping (from context) | ||
| 1..1 | uri | Reference to property mapping depends on | ||
| 0..1 | uri | Code System (if necessary) | ||
| 1..1 | string | Value of the referenced element | ||
| 0..1 | string | Display for the code | ||
| 0..* | see dependsOn | Other concepts that this mapping also produces | ||
| I | 0..1 | BackboneElement | When no match in the mappings + If the mode is 'other-map', a code must be provided + If the mode is 'fixed', a code must be provided | |
| 1..1 | code | provided | fixed | other-map ConceptMapGroupUnmappedMode (Required) | ||
| 0..1 | code | Fixed code when mode = fixed | ||
| 0..1 | string | Display for the code | ||
| 0..1 | uri | Canonical URL for other concept map | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | Detailed information about conditions, problems or diagnoses + If condition is abated, then clinicalStatus must be either inactive, resolved, or remission + Condition.clinicalStatus SHALL be present if verificationStatus is not entered-in-error Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..* | Identifier | External Ids for this condition | |
| ?!ΣI | 0..1 | code | active | recurrence | inactive | remission | resolved Condition Clinical Status Codes (Required) | |
| ?!ΣI | 0..1 | code | provisional | differential | confirmed | refuted | entered-in-error | unknown ConditionVerificationStatus (Required) | |
| 0..* | CodeableConcept | problem-list-item | encounter-diagnosis Condition Category Codes (Example) | ||
| 0..1 | CodeableConcept | Subjective severity of condition Condition/Diagnosis Severity (Preferred) | ||
| Σ | 0..1 | CodeableConcept | Identification of the condition, problem or diagnosis Condition/Problem/Diagnosis Codes (Example) | |
| Σ | 0..* | CodeableConcept | Anatomical location, if relevant SNOMED CT Body Structures (Example) | |
| Σ | 1..1 | Reference(Patient | Group) | Who has the condition? | |
| Σ | 0..1 | Reference(Encounter | EpisodeOfCare) | Encounter or episode when condition first asserted | |
| Σ | 0..1 | Estimated or actual date, date-time, or age | ||
| dateTime | ||||
| Age | ||||
| Period | ||||
| Range | ||||
| string | ||||
| I | 0..1 | If/when in resolution/remission | ||
| dateTime | ||||
| Age | ||||
| boolean | ||||
| Period | ||||
| Range | ||||
| string | ||||
| Σ | 0..1 | dateTime | Date record was believed accurate | |
| Σ | 0..1 | Reference(Practitioner | Patient | RelatedPerson) | Person who asserts this condition | |
| I | 0..1 | BackboneElement | Stage/grade, usually assessed formally + Stage SHALL have summary or assessment | |
| I | 0..1 | CodeableConcept | Simple summary (disease specific) Condition Stage (Example) | |
| I | 0..* | Reference(ClinicalImpression | DiagnosticReport | Observation) | Formal record of assessment | |
| I | 0..* | BackboneElement | Supporting evidence + evidence SHALL have code or details | |
| ΣI | 0..* | CodeableConcept | Manifestation/symptom Manifestation and Symptom Codes (Example) | |
| ΣI | 0..* | Reference(Any) | Supporting information found elsewhere | |
| 0..* | Annotation | Additional information about the Condition | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | A healthcare consumer's policy choices to permits or denies recipients or roles to perform actions for specific purposes and periods of time + Either a Policy or PolicyRule Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..1 | Identifier | Identifier for this record (external references) | |
| ?!Σ | 1..1 | code | draft | proposed | active | rejected | inactive | entered-in-error ConsentState (Required) | |
| Σ | 0..* | CodeableConcept | Classification of the consent statement - for indexing/retrieval Consent Category Codes (Example) | |
| Σ | 1..1 | Reference(Patient) | Who the consent applies to | |
| Σ | 0..1 | Period | Period that this consent applies | |
| Σ | 0..1 | dateTime | When this Consent was created or indexed | |
| Σ | 0..* | Reference(Organization | Patient | Practitioner | RelatedPerson) | Who is agreeing to the policy and exceptions | |
| Σ | 0..* | BackboneElement | Who|what controlled by this consent (or group, by role) | |
| 1..1 | CodeableConcept | How the actor is involved SecurityRoleType (Extensible) | ||
| 1..1 | Reference(Device | Group | CareTeam | Organization | Patient | Practitioner | RelatedPerson) | Resource for the actor (or group, by role) | ||
| Σ | 0..* | CodeableConcept | Actions controlled by this consent Consent Action Codes (Example) | |
| Σ | 0..* | Reference(Organization) | Custodian of the consent | |
| Σ | 0..1 | Source from which this consent is taken | ||
| Attachment | ||||
| Identifier | ||||
| Reference(Consent | DocumentReference | Contract | QuestionnaireResponse) | ||||
| 0..* | BackboneElement | Policies covered by this consent | ||
| I | 0..1 | uri | Enforcement source for policy | |
| I | 0..1 | uri | Specific policy covered by this consent | |
| ΣI | 0..1 | uri | Policy that this consents to | |
| Σ | 0..* | Coding | Security Labels that define affected resources All Security Labels (Extensible) | |
| Σ | 0..* | Coding | Context of activities for which the agreement is made PurposeOfUse (Extensible) | |
| Σ | 0..1 | Period | Timeframe for data controlled by this consent | |
| Σ | 0..* | BackboneElement | Data controlled by this consent | |
| Σ | 1..1 | code | instance | related | dependents | authoredby ConsentDataMeaning (Required) | |
| Σ | 1..1 | Reference(Any) | The actual data reference | |
| Σ | 0..* | BackboneElement | Additional rule - addition or removal of permissions | |
| Σ | 1..1 | code | deny | permit ConsentExceptType (Required) | |
| Σ | 0..1 | Period | Timeframe for this exception | |
| Σ | 0..* | BackboneElement | Who|what controlled by this exception (or group, by role) | |
| 1..1 | CodeableConcept | How the actor is involved SecurityRoleType (Extensible) | ||
| 1..1 | Reference(Device | Group | CareTeam | Organization | Patient | Practitioner | RelatedPerson) | Resource for the actor (or group, by role) | ||
| Σ | 0..* | CodeableConcept | Actions controlled by this exception Consent Action Codes (Example) | |
| Σ | 0..* | Coding | Security Labels that define affected resources All Security Labels (Extensible) | |
| Σ | 0..* | Coding | Context of activities covered by this exception PurposeOfUse (Extensible) | |
| Σ | 0..* | Coding | e.g. Resource Type, Profile, or CDA etc Consent Content Class (Extensible) | |
| Σ | 0..* | Coding | e.g. LOINC or SNOMED CT code, etc in the content Consent Content Codes (Example) | |
| Σ | 0..1 | Period | Timeframe for data controlled by this exception | |
| Σ | 0..* | BackboneElement | Data controlled by this exception | |
| Σ | 1..1 | code | instance | related | dependents | authoredby ConsentDataMeaning (Required) | |
| Σ | 1..1 | Reference(Any) | The actual data reference | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Legal Agreement Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | Identifier | Contract number | |
| ?!Σ | 0..1 | code | amended | appended | cancelled | disputed | entered-in-error | executable | executed | negotiable | offered | policy | rejected | renewed | revoked | resolved | terminated Contract Resource Status Codes (Required) | |
| Σ | 0..1 | dateTime | When this Contract was issued | |
| Σ | 0..1 | Period | Effective time | |
| Σ | 0..* | Reference(Any) | Contract Target Entity | |
| Σ | 0..* | Reference(Any) | Context of the Contract | |
| 0..* | Reference(Organization) | Authority under which this Contract has standing | ||
| 0..* | Reference(Location) | Domain in which this Contract applies | ||
| Σ | 0..1 | CodeableConcept | Type or form Contract Type Codes (Example) | |
| Σ | 0..* | CodeableConcept | Subtype within the context of type Contract Subtype Codes (Example) | |
| 0..* | CodeableConcept | Action stipulated by this Contract Contract Action Codes (Example) | ||
| 0..* | CodeableConcept | Rationale for the stiplulated action PurposeOfUse (Example) | ||
| 0..1 | CodeableConcept | Decision by Grantor ActConsentDirective (Extensible) | ||
| 0..1 | CodeableConcept | Content derived from the basal information Contract Content Derivation Codes (Example) | ||
| Σ | 0..* | Coding | Security Labels that define affected resources All Security Labels (Extensible) | |
| 0..* | BackboneElement | Entity being ascribed responsibility | ||
| 1..1 | Reference(Contract | Device | Group | Location | Organization | Patient | Practitioner | RelatedPerson | Substance) | Contract Agent Type | ||
| 0..* | CodeableConcept | Role type of the agent Contract Actor Role Codes (Example) | ||
| 0..* | BackboneElement | Contract Signatory | ||
| 1..1 | Coding | Contract Signatory Role Contract Signer Type Codes (Preferred) | ||
| 1..1 | Reference(Organization | Patient | Practitioner | RelatedPerson) | Contract Signatory Party | ||
| 1..* | Signature | Contract Documentation Signature | ||
| 0..* | BackboneElement | Contract Valued Item List | ||
| 0..1 | Contract Valued Item Type | |||
| CodeableConcept | ||||
| Reference(Any) | ||||
| 0..1 | Identifier | Contract Valued Item Number | ||
| 0..1 | dateTime | Contract Valued Item Effective Tiem | ||
| 0..1 | SimpleQuantity | Count of Contract Valued Items | ||
| 0..1 | Money | Contract Valued Item fee, charge, or cost | ||
| 0..1 | decimal | Contract Valued Item Price Scaling Factor | ||
| 0..1 | decimal | Contract Valued Item Difficulty Scaling Factor | ||
| 0..1 | Money | Total Contract Valued Item Value | ||
| 0..* | BackboneElement | Contract Term List | ||
| Σ | 0..1 | Identifier | Contract Term Number | |
| Σ | 0..1 | dateTime | Contract Term Issue Date Time | |
| Σ | 0..1 | Period | Contract Term Effective Time | |
| 0..1 | CodeableConcept | Contract Term Type or Form Contract Term Type Codes (Example) | ||
| 0..1 | CodeableConcept | Contract Term Type specific classification Contract Term Subtype Codes (Example) | ||
| Σ | 0..* | Reference(Any) | Context of the Contract term | |
| 0..* | CodeableConcept | Contract Term Activity Contract Action Codes (Example) | ||
| 0..* | CodeableConcept | Purpose for the Contract Term Action PurposeOfUse (Example) | ||
| Σ | 0..* | Coding | Security Labels that define affected terms All Security Labels (Extensible) | |
| 0..* | BackboneElement | Contract Term Agent List | ||
| 1..1 | Reference(Contract | Device | Group | Location | Organization | Patient | Practitioner | RelatedPerson | Substance) | Contract Term Agent Subject | ||
| 0..* | CodeableConcept | Type of the Contract Term Agent Contract Actor Role Codes (Example) | ||
| 0..1 | string | Human readable Contract term text | ||
| 0..* | BackboneElement | Contract Term Valued Item List | ||
| 0..1 | Contract Term Valued Item Type | |||
| CodeableConcept | ||||
| Reference(Any) | ||||
| 0..1 | Identifier | Contract Term Valued Item Number | ||
| 0..1 | dateTime | Contract Term Valued Item Effective Tiem | ||
| 0..1 | SimpleQuantity | Contract Term Valued Item Count | ||
| 0..1 | Money | Contract Term Valued Item fee, charge, or cost | ||
| 0..1 | decimal | Contract Term Valued Item Price Scaling Factor | ||
| 0..1 | decimal | Contract Term Valued Item Difficulty Scaling Factor | ||
| 0..1 | Money | Total Contract Term Valued Item Value | ||
| 0..* | see term | Nested Contract Term Group | ||
| 0..1 | Binding Contract | |||
| Attachment | ||||
| Reference(Composition | DocumentReference | QuestionnaireResponse) | ||||
| 0..* | BackboneElement | Contract Friendly Language | ||
| 1..1 | Easily comprehended representation of this Contract | |||
| Attachment | ||||
| Reference(Composition | DocumentReference | QuestionnaireResponse) | ||||
| 0..* | BackboneElement | Contract Legal Language | ||
| 1..1 | Contract Legal Text | |||
| Attachment | ||||
| Reference(Composition | DocumentReference | QuestionnaireResponse) | ||||
| 0..* | BackboneElement | Computable Contract Language | ||
| 1..1 | Computable Contract Rules | |||
| Attachment | ||||
| Reference(DocumentReference) | ||||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Insurance or medical plan or a payment agreement Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | The primary coverage ID | |
| ?!Σ | 0..1 | code | active | cancelled | draft | entered-in-error Financial Resource Status Codes (Required) | |
| Σ | 0..1 | CodeableConcept | Type of coverage such as medical or accident Coverage Type and Self-Pay Codes (Preferred) | |
| Σ | 0..1 | Reference(Patient | RelatedPerson | Organization) | Owner of the policy | |
| Σ | 0..1 | Reference(Patient | RelatedPerson) | Subscriber to the policy | |
| Σ | 0..1 | string | ID assigned to the Subscriber | |
| Σ | 0..1 | Reference(Patient) | Plan Beneficiary | |
| 0..1 | CodeableConcept | Beneficiary relationship to the Subscriber Policyholder Relationship Codes (Example) | ||
| Σ | 0..1 | Period | Coverage start and end dates | |
| Σ | 0..* | Reference(Organization | Patient | RelatedPerson) | Identifier for the plan or agreement issuer | |
| 0..1 | BackboneElement | Additional coverage classifications | ||
| Σ | 0..1 | string | An identifier for the group | |
| Σ | 0..1 | string | Display text for an identifier for the group | |
| Σ | 0..1 | string | An identifier for the subsection of the group | |
| Σ | 0..1 | string | Display text for the subsection of the group | |
| Σ | 0..1 | string | An identifier for the plan | |
| Σ | 0..1 | string | Display text for the plan | |
| Σ | 0..1 | string | An identifier for the subsection of the plan | |
| Σ | 0..1 | string | Display text for the subsection of the plan | |
| Σ | 0..1 | string | An identifier for the class | |
| Σ | 0..1 | string | Display text for the class | |
| Σ | 0..1 | string | An identifier for the subsection of the class | |
| Σ | 0..1 | string | Display text for the subsection of the subclass | |
| Σ | 0..1 | string | Dependent number | |
| Σ | 0..1 | string | The plan instance or sequence counter | |
| Σ | 0..1 | positiveInt | Relative order of the coverage | |
| Σ | 0..1 | string | Insurer network | |
| 0..* | Reference(Contract) | Contract details | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Resource data element Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | uri | Logical URI to reference this data element (globally unique) | |
| Σ | 0..* | Identifier | Additional identifier for the data element | |
| Σ | 0..1 | string | Business version of the data element | |
| ?!Σ | 1..1 | code | draft | active | retired | unknown PublicationStatus (Required) | |
| ?!Σ | 0..1 | boolean | For testing purposes, not real usage | |
| Σ | 0..1 | dateTime | Date this was last changed | |
| Σ | 0..1 | string | Name of the publisher (organization or individual) | |
| Σ | 0..1 | string | Name for this data element (computer friendly) | |
| Σ | 0..1 | string | Name for this data element (human friendly) | |
| Σ | 0..* | ContactDetail | Contact details for the publisher | |
| Σ | 0..* | UsageContext | Context the content is intended to support | |
| Σ | 0..* | CodeableConcept | Intended jurisdiction for data element (if applicable) Jurisdiction ValueSet (Extensible) | |
| 0..1 | markdown | Use and/or publishing restrictions | ||
| Σ | 0..1 | code | comparable | fully-specified | equivalent | convertable | scaleable | flexible DataElementStringency (Required) | |
| I | 0..* | BackboneElement | External specification mapped to + At least one of name or uri SHALL be present | |
| 1..1 | id | Internal id when this mapping is used | ||
| 0..1 | uri | Identifies what this mapping refers to | ||
| 0..1 | string | Names what this mapping refers to | ||
| 0..1 | string | Versions, issues, scope limitations, etc. | ||
| ΣI | 1..* | ElementDefinition | Definition of element + No base allowed + No slicing allowed | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Clinical issue with action Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | Identifier | Unique id for the detected issue | |
| ?!Σ | 1..1 | code | registered | preliminary | final | amended + ObservationStatus (Required) | |
| Σ | 0..1 | CodeableConcept | Issue Category, e.g. drug-drug, duplicate therapy, etc. Detected Issue Category (Preferred) | |
| Σ | 0..1 | code | high | moderate | low DetectedIssueSeverity (Required) | |
| Σ | 0..1 | Reference(Patient) | Associated patient | |
| Σ | 0..1 | dateTime | When identified | |
| Σ | 0..1 | Reference(Practitioner | Device) | The provider or device that identified the issue | |
| Σ | 0..* | Reference(Any) | Problem resource | |
| 0..1 | string | Description and context | ||
| 0..1 | uri | Authority for issue | ||
| 0..* | BackboneElement | Step taken to address | ||
| 1..1 | CodeableConcept | What mitigation? Detected Issue Mitigation Action (Preferred) | ||
| 0..1 | dateTime | Date committed | ||
| 0..1 | Reference(Practitioner) | Who is committing? | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Item used in healthcare Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| 0..* | Identifier | Instance identifier | ||
| Σ | 0..1 | BackboneElement | Unique Device Identifier (UDI) Barcode string | |
| Σ | 0..1 | string | Mandatory fixed portion of UDI | |
| Σ | 0..1 | string | Device Name as appears on UDI label | |
| 0..1 | uri | Regional UDI authority | ||
| Σ | 0..1 | string | UDI Human Readable Barcode String | |
| Σ | 0..1 | base64Binary | UDI Machine Readable Barcode String | |
| 0..1 | uri | UDI Issuing Organization | ||
| 0..1 | code | barcode | rfid | manual + UDIEntryType (Required) | ||
| ?!Σ | 0..1 | code | active | inactive | entered-in-error | unknown FHIRDeviceStatus (Required) | |
| 0..1 | CodeableConcept | What kind of device this is FHIR Device Types (Example) | ||
| 0..1 | string | Lot number of manufacture | ||
| 0..1 | string | Name of device manufacturer | ||
| 0..1 | dateTime | Date when the device was made | ||
| 0..1 | dateTime | Date and time of expiry of this device (if applicable) | ||
| 0..1 | string | Model id assigned by the manufacturer | ||
| 0..1 | string | Version number (i.e. software) | ||
| 0..1 | Reference(Patient) | Patient to whom Device is affixed | ||
| 0..1 | Reference(Organization) | Organization responsible for device | ||
| 0..* | ContactPoint | Details for human/organization for support | ||
| 0..1 | Reference(Location) | Where the resource is found | ||
| 0..1 | uri | Network address to contact device | ||
| 0..* | Annotation | Device notes and comments | ||
| Σ | 0..* | CodeableConcept | Safety Characteristics of Device DeviceSafety (Example) | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| Σ | DomainResource | An instance of a medical-related component of a medical device Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 1..1 | Identifier | Instance id assigned by the software stack | |
| Σ | 1..1 | CodeableConcept | What kind of component it is FHIR Device Types (Preferred) | |
| Σ | 0..1 | instant | Recent system change timestamp | |
| Σ | 0..1 | Reference(Device) | Top-level device resource link | |
| Σ | 0..1 | Reference(DeviceComponent) | Parent resource link | |
| Σ | 0..* | CodeableConcept | Current operational status of the component, for example On, Off or Standby DeviceComponentOperationalStatus (Extensible) | |
| Σ | 0..1 | CodeableConcept | Current supported parameter group DeviceComponentParameterGroup (Extensible) | |
| Σ | 0..1 | code | other | chemical | electrical | impedance | nuclear | optical | thermal | biological | mechanical | acoustical | manual+ MeasmntPrinciple (Required) | |
| Σ | 0..* | BackboneElement | Specification details such as Component Revisions, or Serial Numbers | |
| Σ | 0..1 | CodeableConcept | Type or kind of production specification, for example serial number or software revision DeviceSpecificationSpecType (Extensible) | |
| Σ | 0..1 | Identifier | Internal component unique identification | |
| Σ | 0..1 | string | A printable string defining the component | |
| Σ | 0..1 | CodeableConcept | Language code for the human-readable text strings produced by the device Common Languages (Extensible but limited to All Languages) | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| Σ | DomainResource | Measurement, calculation or setting capability of a medical device Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 1..1 | Identifier | Unique identifier of this DeviceMetric | |
| Σ | 1..1 | CodeableConcept | Identity of metric, for example Heart Rate or PEEP Setting Device Metric and Component Types (Preferred) | |
| Σ | 0..1 | CodeableConcept | Unit of Measure for the Metric Device Metric and Component Types (Preferred) | |
| Σ | 0..1 | Reference(Device) | Describes the link to the source Device | |
| Σ | 0..1 | Reference(DeviceComponent) | Describes the link to the parent DeviceComponent | |
| Σ | 0..1 | code | on | off | standby | entered-in-error DeviceMetricOperationalStatus (Required) | |
| Σ | 0..1 | code | black | red | green | yellow | blue | magenta | cyan | white DeviceMetricColor (Required) | |
| Σ | 1..1 | code | measurement | setting | calculation | unspecified DeviceMetricCategory (Required) | |
| Σ | 0..1 | Timing | Describes the measurement repetition time | |
| Σ | 0..* | BackboneElement | Describes the calibrations that have been performed or that are required to be performed | |
| Σ | 0..1 | code | unspecified | offset | gain | two-point DeviceMetricCalibrationType (Required) | |
| Σ | 0..1 | code | not-calibrated | calibration-required | calibrated | unspecified DeviceMetricCalibrationState (Required) | |
| Σ | 0..1 | instant | Describes the time last calibration has been performed | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Medical device request Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | External Request identifier | |
| Σ | 0..* | Reference(ActivityDefinition | PlanDefinition) | Protocol or definition | |
| Σ | 0..* | Reference(Any) | What request fulfills | |
| Σ | 0..* | Reference(Any) | What request replaces | |
| Σ | 0..1 | Identifier | Identifier of composite request | |
| ?!Σ | 0..1 | code | draft | active | suspended | completed | entered-in-error | cancelled RequestStatus (Required) | |
| ?!Σ | 1..1 | CodeableConcept | proposal | plan | original-order | encoded | reflex-order RequestIntent (Required) | |
| Σ | 0..1 | code | Indicates how quickly the {{title}} should be addressed with respect to other requests RequestPriority (Required) | |
| Σ | 1..1 | Device requested FHIR Device Types (Example) | ||
| Reference(Device) | ||||
| CodeableConcept | ||||
| Σ | 1..1 | Reference(Patient | Group | Location | Device) | Focus of request | |
| Σ | 0..1 | Reference(Encounter | EpisodeOfCare) | Encounter or Episode motivating request | |
| Σ | 0..1 | Desired time or schedule for use | ||
| dateTime | ||||
| Period | ||||
| Timing | ||||
| Σ | 0..1 | dateTime | When recorded | |
| Σ | 0..1 | BackboneElement | Who/what is requesting diagnostics | |
| Σ | 1..1 | Reference(Device | Practitioner | Organization) | Individual making the request | |
| Σ | 0..1 | Reference(Organization) | Organization agent is acting for | |
| Σ | 0..1 | CodeableConcept | Fille role Participant Roles (Example) | |
| Σ | 0..1 | Reference(Practitioner | Organization | Patient | Device | RelatedPerson | HealthcareService) | Requested Filler | |
| Σ | 0..* | CodeableConcept | Coded Reason for request Condition/Problem/Diagnosis Codes (Example) | |
| Σ | 0..* | Reference(Any) | Linked Reason for request | |
| 0..* | Reference(Any) | Additional clinical information | ||
| 0..* | Annotation | Notes or comments | ||
| 0..* | Reference(Provenance) | Request provenance | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Record of use of a device Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| 0..* | Identifier | External identifier for this record | ||
| ?!Σ | 1..1 | code | active | completed | entered-in-error + DeviceUseStatementStatus (Required) | |
| 1..1 | Reference(Patient | Group) | Patient using device | ||
| 0..1 | Period | Period device was used | ||
| 0..1 | How often the device was used | |||
| Timing | ||||
| Period | ||||
| dateTime | ||||
| 0..1 | dateTime | When statement was recorded | ||
| 0..1 | Reference(Patient | Practitioner | RelatedPerson) | Who made the statement | ||
| 1..1 | Reference(Device) | Reference to device used | ||
| 0..* | CodeableConcept | Why device was used | ||
| 0..1 | CodeableConcept | Target body site SNOMED CT Body Structures (Example) | ||
| 0..* | Annotation | Addition details (comments, instructions) | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | A Diagnostic report - a combination of request information, atomic results, images, interpretation, as well as formatted reports Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | Business identifier for report | |
| 0..* | Reference(CarePlan | ImmunizationRecommendation | MedicationRequest | NutritionOrder | ProcedureRequest | ReferralRequest) | What was requested | ||
| ?!Σ | 1..1 | code | registered | partial | preliminary | final + DiagnosticReportStatus (Required) | |
| Σ | 0..1 | CodeableConcept | Service category Diagnostic Service Section Codes (Example) | |
| Σ | 1..1 | CodeableConcept | Name/Code for this diagnostic report LOINC Diagnostic Report Codes (Preferred) | |
| Σ | 0..1 | Reference(Patient | Group | Device | Location) | The subject of the report - usually, but not always, the patient | |
| Σ | 0..1 | Reference(Encounter | EpisodeOfCare) | Health care event when test ordered | |
| Σ | 0..1 | Clinically relevant time/time-period for report | ||
| dateTime | ||||
| Period | ||||
| Σ | 0..1 | instant | DateTime this version was released | |
| Σ | 0..* | BackboneElement | Participants in producing the report | |
| Σ | 0..1 | CodeableConcept | Type of performer Procedure Performer Role Codes (Example) | |
| Σ | 1..1 | Reference(Practitioner | Organization) | Practitioner or Organization participant | |
| 0..* | Reference(Specimen) | Specimens this report is based on | ||
| 0..* | Reference(Observation) | Observations - simple, or complex nested groups | ||
| 0..* | Reference(ImagingStudy | ImagingManifest) | Reference to full details of imaging associated with the diagnostic report | ||
| Σ | 0..* | BackboneElement | Key images associated with this report | |
| 0..1 | string | Comment about the image (e.g. explanation) | ||
| Σ | 1..1 | Reference(Media) | Reference to the image source | |
| 0..1 | string | Clinical Interpretation of test results | ||
| 0..* | CodeableConcept | Codes for the conclusion SNOMED CT Clinical Findings (Example) | ||
| 0..* | Attachment | Entire report as issued | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| Σ | DomainResource | A list that defines a set of documents Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..1 | Identifier | Unique Identifier for the set of documents | |
| Σ | 0..* | Identifier | Other identifiers for the manifest | |
| ?!Σ | 1..1 | code | current | superseded | entered-in-error DocumentReferenceStatus (Required) | |
| Σ | 0..1 | CodeableConcept | Kind of document set Document Type Value Set (Preferred) | |
| Σ | 0..1 | Reference(Patient | Practitioner | Group | Device) | The subject of the set of documents | |
| Σ | 0..1 | dateTime | When this document manifest created | |
| Σ | 0..* | Reference(Practitioner | Organization | Device | Patient | RelatedPerson) | Who and/or what authored the manifest | |
| Σ | 0..* | Reference(Patient | Practitioner | RelatedPerson | Organization) | Intended to get notified about this set of documents | |
| Σ | 0..1 | uri | The source system/application/software | |
| Σ | 0..1 | string | Human-readable description (title) | |
| Σ | 1..* | BackboneElement | The items included | |
| Σ | 1..1 | Contents of this set of documents | ||
| Attachment | ||||
| Reference(Any) | ||||
| Σ | 0..* | BackboneElement | Related things | |
| Σ | 0..1 | Identifier | Identifiers of things that are related | |
| Σ | 0..1 | Reference(Any) | Related Resource | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | A reference to a document Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | Identifier | Master Version Specific Identifier | |
| Σ | 0..* | Identifier | Other identifiers for the document | |
| ?!Σ | 1..1 | code | current | superseded | entered-in-error DocumentReferenceStatus (Required) | |
| Σ | 0..1 | code | preliminary | final | appended | amended | entered-in-error CompositionStatus (Required) | |
| Σ | 1..1 | CodeableConcept | Kind of document (LOINC if possible) Document Type Value Set (Preferred) | |
| Σ | 0..1 | CodeableConcept | Categorization of document Document Class Value Set (Example) | |
| Σ | 0..1 | Reference(Patient | Practitioner | Group | Device) | Who/what is the subject of the document | |
| Σ | 0..1 | dateTime | Document creation time | |
| Σ | 1..1 | instant | When this document reference was created | |
| Σ | 0..* | Reference(Practitioner | Organization | Device | Patient | RelatedPerson) | Who and/or what authored the document | |
| Σ | 0..1 | Reference(Practitioner | Organization) | Who/what authenticated the document | |
| Σ | 0..1 | Reference(Organization) | Organization which maintains the document | |
| ?!Σ | 0..* | BackboneElement | Relationships to other documents | |
| Σ | 1..1 | code | replaces | transforms | signs | appends DocumentRelationshipType (Required) | |
| Σ | 1..1 | Reference(DocumentReference) | Target of the relationship | |
| Σ | 0..1 | string | Human-readable description (title) | |
| Σ | 0..* | CodeableConcept | Document security-tags All Security Labels (Extensible) | |
| Σ | 1..* | BackboneElement | Document referenced | |
| Σ | 1..1 | Attachment | Where to access the document | |
| Σ | 0..1 | Coding | Format/content rules for the document DocumentReference Format Code Set (Preferred) | |
| Σ | 0..1 | BackboneElement | Clinical context of document | |
| Σ | 0..1 | Reference(Encounter) | Context of the document content | |
| Σ | 0..* | CodeableConcept | Main clinical acts documented v3 Code System ActCode (Example) | |
| Σ | 0..1 | Period | Time of service that is being documented | |
| Σ | 0..1 | CodeableConcept | Kind of facility where patient was seen Facility Type Code Value Set (Example) | |
| Σ | 0..1 | CodeableConcept | Additional details about where the content was created (e.g. clinical specialty) Practice Setting Code Value Set (Example) | |
| Σ | 0..1 | Reference(Patient) | Patient demographics from source | |
| Σ | 0..* | BackboneElement | Related identifiers or resources | |
| Σ | 0..1 | Identifier | Identifier of related objects or events | |
| Σ | 0..1 | Reference(Any) | Related Resource | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | Resource | A resource with narrative, extensions, and contained resources + If the resource is contained in another resource, it SHALL NOT contain nested Resources + If the resource is contained in another resource, it SHALL NOT contain any narrative + If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated + If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource Elements defined in Ancestors: id, meta, implicitRules, language | ||
| I | 0..1 | Narrative | Text summary of the resource, for human interpretation | |
| 0..* | Resource | Contained, inline Resources | ||
| 0..* | Extension | Additional Content defined by implementations | ||
| ?! | 0..* | Extension | Extensions that cannot be ignored | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Determine insurance validity and scope of coverage Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| 0..* | Identifier | Business Identifier | ||
| ?!Σ | 0..1 | code | active | cancelled | draft | entered-in-error Financial Resource Status Codes (Required) | |
| 0..1 | CodeableConcept | Desired processing priority Process Priority Codes (Example) | ||
| 0..1 | Reference(Patient) | The subject of the Products and Services | ||
| 0..1 | Estimated date or dates of Service | |||
| date | ||||
| Period | ||||
| 0..1 | dateTime | Creation date | ||
| 0..1 | Reference(Practitioner) | Author | ||
| 0..1 | Reference(Practitioner) | Responsible practitioner | ||
| 0..1 | Reference(Organization) | Responsible organization | ||
| 0..1 | Reference(Organization) | Target | ||
| 0..1 | Reference(Location) | Servicing Facility | ||
| 0..1 | Reference(Coverage) | Insurance or medical plan | ||
| 0..1 | string | Business agreement | ||
| 0..1 | CodeableConcept | Type of services covered Benefit Category Codes (Example) | ||
| 0..1 | CodeableConcept | Detailed services covered within the type Benefit SubCategory Codes (Example) | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | EligibilityResponse resource Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| 0..* | Identifier | Business Identifier | ||
| ?!Σ | 0..1 | code | active | cancelled | draft | entered-in-error Financial Resource Status Codes (Required) | |
| 0..1 | dateTime | Creation date | ||
| 0..1 | Reference(Practitioner) | Responsible practitioner | ||
| 0..1 | Reference(Organization) | Responsible organization | ||
| 0..1 | Reference(EligibilityRequest) | Eligibility reference | ||
| 0..1 | CodeableConcept | complete | error | partial RemittanceOutcome (Required) | ||
| 0..1 | string | Disposition Message | ||
| 0..1 | Reference(Organization) | Insurer issuing the coverage | ||
| 0..1 | boolean | Coverage inforce indicator | ||
| 0..* | BackboneElement | Details by insurance coverage | ||
| 0..1 | Reference(Coverage) | Updated Coverage details | ||
| 0..1 | Reference(Contract) | Contract details | ||
| 0..* | BackboneElement | Benefits by Category | ||
| 1..1 | CodeableConcept | Type of services covered Benefit Category Codes (Example) | ||
| 0..1 | CodeableConcept | Detailed services covered within the type Benefit SubCategory Codes (Example) | ||
| 0..1 | boolean | Excluded from the plan | ||
| 0..1 | string | Short name for the benefit | ||
| 0..1 | string | Description of the benefit or services covered | ||
| 0..1 | CodeableConcept | In or out of network Network Type Codes (Example) | ||
| 0..1 | CodeableConcept | Individual or family Unit Type Codes (Example) | ||
| 0..1 | CodeableConcept | Annual or lifetime Benefit Term Codes (Example) | ||
| 0..* | BackboneElement | Benefit Summary | ||
| 1..1 | CodeableConcept | Deductable, visits, benefit amount Benefit Type Codes (Example) | ||
| 0..1 | Benefits allowed | |||
| unsignedInt | ||||
| string | ||||
| Money | ||||
| 0..1 | Benefits used | |||
| unsignedInt | ||||
| Money | ||||
| 0..1 | CodeableConcept | Printed Form Identifier Form Codes (Example) | ||
| 0..* | BackboneElement | Processing errors | ||
| 1..1 | CodeableConcept | Error code detailing processing issues Adjudication Error Codes (Example) | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | An interaction during which services are provided to the patient Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | Identifier(s) by which this encounter is known | |
| ?!Σ | 1..1 | code | planned | arrived | triaged | in-progress | onleave | finished | cancelled + EncounterStatus (Required) | |
| 0..* | BackboneElement | List of past encounter statuses | ||
| 1..1 | code | planned | arrived | triaged | in-progress | onleave | finished | cancelled + EncounterStatus (Required) | ||
| 1..1 | Period | The time that the episode was in the specified status | ||
| Σ | 0..1 | Coding | inpatient | outpatient | ambulatory | emergency + ActEncounterCode (Extensible) | |
| 0..* | BackboneElement | List of past encounter classes | ||
| 1..1 | Coding | inpatient | outpatient | ambulatory | emergency + ActEncounterCode (Extensible) | ||
| 1..1 | Period | The time that the episode was in the specified class | ||
| Σ | 0..* | CodeableConcept | Specific type of encounter EncounterType (Example) | |
| 0..1 | CodeableConcept | Indicates the urgency of the encounter v3 Code System ActPriority (Example) | ||
| Σ | 0..1 | Reference(Patient | Group) | The patient ro group present at the encounter | |
| Σ | 0..* | Reference(EpisodeOfCare) | Episode(s) of care that this encounter should be recorded against | |
| 0..* | Reference(ReferralRequest) | The ReferralRequest that initiated this encounter | ||
| Σ | 0..* | BackboneElement | List of participants involved in the encounter | |
| Σ | 0..* | CodeableConcept | Role of participant in encounter ParticipantType (Extensible) | |
| 0..1 | Period | Period of time during the encounter that the participant participated | ||
| Σ | 0..1 | Reference(Practitioner | RelatedPerson) | Persons involved in the encounter other than the patient | |
| Σ | 0..1 | Reference(Appointment) | The appointment that scheduled this encounter | |
| 0..1 | Period | The start and end time of the encounter | ||
| 0..1 | Duration | Quantity of time the encounter lasted (less time absent) | ||
| Σ | 0..* | CodeableConcept | Reason the encounter takes place (code) Encounter Reason Codes (Preferred) | |
| Σ | 0..* | BackboneElement | The list of diagnosis relevant to this encounter | |
| 1..1 | Reference(Condition | Procedure) | Reason the encounter takes place (resource) | ||
| 0..1 | CodeableConcept | Role that this diagnosis has within the encounter (e.g. admission, billing, discharge …) DiagnosisRole (Preferred) | ||
| 0..1 | positiveInt | Ranking of the diagnosis (for each role type) | ||
| 0..* | Reference(Account) | The set of accounts that may be used for billing for this Encounter | ||
| 0..1 | BackboneElement | Details about the admission to a healthcare service | ||
| 0..1 | Identifier | Pre-admission identifier | ||
| 0..1 | Reference(Location) | The location from which the patient came before admission | ||
| 0..1 | CodeableConcept | From where patient was admitted (physician referral, transfer) AdmitSource (Preferred) | ||
| 0..1 | CodeableConcept | The type of hospital re-admission that has occurred (if any). If the value is absent, then this is not identified as a readmission v2 Re-Admission Indicator (Example) | ||
| 0..* | CodeableConcept | Diet preferences reported by the patient Diet (Example) | ||
| 0..* | CodeableConcept | Special courtesies (VIP, board member) SpecialCourtesy (Preferred) | ||
| 0..* | CodeableConcept | Wheelchair, translator, stretcher, etc. SpecialArrangements (Preferred) | ||
| 0..1 | Reference(Location) | Location to which the patient is discharged | ||
| 0..1 | CodeableConcept | Category or kind of location after discharge DischargeDisposition (Example) | ||
| 0..* | BackboneElement | List of locations where the patient has been | ||
| 1..1 | Reference(Location) | Location the encounter takes place | ||
| 0..1 | code | planned | active | reserved | completed EncounterLocationStatus (Required) | ||
| 0..1 | Period | Time period during which the patient was present at the location | ||
| 0..1 | Reference(Organization) | The custodian organization of this Encounter record | ||
| 0..1 | Reference(Encounter) | Another Encounter this encounter is part of | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | The technical details of an endpoint that can be used for electronic services Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | Identifies this endpoint across multiple systems | |
| ?!Σ | 1..1 | code | active | suspended | error | off | entered-in-error | test EndpointStatus (Required) | |
| Σ | 1..1 | Coding | Protocol/Profile/Standard to be used with this endpoint connection Endpoint Connection Type (Extensible) | |
| Σ | 0..1 | string | A name that this endpoint can be identified by | |
| Σ | 0..1 | Reference(Organization) | Organization that manages this endpoint (may not be the organization that exposes the endpoint) | |
| 0..* | ContactPoint | Contact details for source (e.g. troubleshooting) | ||
| Σ | 0..1 | Period | Interval the endpoint is expected to be operational | |
| Σ | 1..* | CodeableConcept | The type of content that may be used at this endpoint (e.g. XDS Discharge summaries) Endpoint Payload Type (Example) | |
| Σ | 0..* | code | Mimetype to send. If not specified, the content could be anything (including no payload, if the connectionType defined this) MimeType (Required) | |
| Σ | 1..1 | uri | The technical base address for connecting to this endpoint | |
| 0..* | string | Usage depends on the channel type | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Enrollment request Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| 0..* | Identifier | Business Identifier | ||
| ?!Σ | 0..1 | code | active | cancelled | draft | entered-in-error Financial Resource Status Codes (Required) | |
| 0..1 | dateTime | Creation date | ||
| 0..1 | Reference(Organization) | Target | ||
| 0..1 | Reference(Practitioner) | Responsible practitioner | ||
| 0..1 | Reference(Organization) | Responsible organization | ||
| 0..1 | Reference(Patient) | The subject of the Products and Services | ||
| 0..1 | Reference(Coverage) | Insurance information | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | EnrollmentResponse resource Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| 0..* | Identifier | Business Identifier | ||
| ?!Σ | 0..1 | code | active | cancelled | draft | entered-in-error Financial Resource Status Codes (Required) | |
| 0..1 | Reference(EnrollmentRequest) | Claim reference | ||
| 0..1 | CodeableConcept | complete | error | partial RemittanceOutcome (Required) | ||
| 0..1 | string | Disposition Message | ||
| 0..1 | dateTime | Creation date | ||
| 0..1 | Reference(Organization) | Insurer | ||
| 0..1 | Reference(Practitioner) | Responsible practitioner | ||
| 0..1 | Reference(Organization) | Responsible organization | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | An association of a Patient with an Organization and Healthcare Provider(s) for a period of time that the Organization assumes some level of responsibility Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| 0..* | Identifier | Business Identifier(s) relevant for this EpisodeOfCare | ||
| ?!Σ | 1..1 | code | planned | waitlist | active | onhold | finished | cancelled | entered-in-error EpisodeOfCareStatus (Required) | |
| 0..* | BackboneElement | Past list of status codes (the current status may be included to cover the start date of the status) | ||
| 1..1 | code | planned | waitlist | active | onhold | finished | cancelled | entered-in-error EpisodeOfCareStatus (Required) | ||
| 1..1 | Period | Duration the EpisodeOfCare was in the specified status | ||
| Σ | 0..* | CodeableConcept | Type/class - e.g. specialist referral, disease management EpisodeOfCareType (Example) | |
| Σ | 0..* | BackboneElement | The list of diagnosis relevant to this episode of care | |
| Σ | 1..1 | Reference(Condition) | Conditions/problems/diagnoses this episode of care is for | |
| Σ | 0..1 | CodeableConcept | Role that this diagnosis has within the episode of care (e.g. admission, billing, discharge …) DiagnosisRole (Preferred) | |
| Σ | 0..1 | positiveInt | Ranking of the diagnosis (for each role type) | |
| Σ | 1..1 | Reference(Patient) | The patient who is the focus of this episode of care | |
| Σ | 0..1 | Reference(Organization) | Organization that assumes care | |
| Σ | 0..1 | Period | Interval during responsibility is assumed | |
| 0..* | Reference(ReferralRequest) | Originating Referral Request(s) | ||
| 0..1 | Reference(Practitioner) | Care manager/care co-ordinator for the patient | ||
| 0..* | Reference(CareTeam) | Other practitioners facilitating this episode of care | ||
| 0..* | Reference(Account) | The set of accounts that may be used for billing for this EpisodeOfCare | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Defines behaviour and contraints on the ValueSet Expansion operation Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | uri | Logical URI to reference this expansion profile (globally unique) | |
| Σ | 0..1 | Identifier | Additional identifier for the expansion profile | |
| Σ | 0..1 | string | Business version of the expansion profile | |
| Σ | 0..1 | string | Name for this expansion profile (computer friendly) | |
| ?!Σ | 1..1 | code | draft | active | retired | unknown PublicationStatus (Required) | |
| ?!Σ | 0..1 | boolean | For testing purposes, not real usage | |
| Σ | 0..1 | dateTime | Date this was last changed | |
| Σ | 0..1 | string | Name of the publisher (organization or individual) | |
| Σ | 0..* | ContactDetail | Contact details for the publisher | |
| 0..1 | markdown | Natural language description of the expansion profile | ||
| Σ | 0..* | UsageContext | Context the content is intended to support | |
| Σ | 0..* | CodeableConcept | Intended jurisdiction for expansion profile (if applicable) Jurisdiction ValueSet (Extensible) | |
| Σ | 0..* | BackboneElement | Fix use of a code system to a particular version | |
| Σ | 1..1 | uri | System to have its version fixed | |
| Σ | 1..1 | string | Specific version of the code system referred to | |
| Σ | 1..1 | code | default | check | override SystemVersionProcessingMode (Required) | |
| Σ | 0..1 | BackboneElement | Systems/Versions to be exclude | |
| Σ | 1..1 | uri | The specific code system to be excluded | |
| Σ | 0..1 | string | Specific version of the code system referred to | |
| Σ | 0..1 | boolean | Whether the expansion should include concept designations | |
| Σ | 0..1 | BackboneElement | When the expansion profile imposes designation contraints | |
| Σ | 0..1 | BackboneElement | Designations to be included | |
| ΣI | 0..* | BackboneElement | The designation to be included + SHALL have at least one of language or use | |
| Σ | 0..1 | code | Human language of the designation to be included Common Languages (Extensible but limited to All Languages) | |
| Σ | 0..1 | Coding | What kind of Designation to include Designation Use (Required) | |
| Σ | 0..1 | BackboneElement | Designations to be excluded | |
| ΣI | 0..* | BackboneElement | The designation to be excluded + SHALL have at least one of language or use | |
| Σ | 0..1 | code | Human language of the designation to be excluded Common Languages (Extensible but limited to All Languages) | |
| Σ | 0..1 | Coding | What kind of Designation to exclude Designation Use (Required) | |
| Σ | 0..1 | boolean | Include or exclude the value set definition in the expansion | |
| Σ | 0..1 | boolean | Include or exclude inactive concepts in the expansion | |
| Σ | 0..1 | boolean | Nested codes in the expansion or not | |
| Σ | 0..1 | boolean | Include or exclude codes which cannot be rendered in user interfaces in the value set expansion | |
| Σ | 0..1 | boolean | Include or exclude codes which are post coordinated expressions in the value set expansion | |
| Σ | 0..1 | code | Specify the language for the display element of codes in the value set expansion Common Languages (Extensible but limited to All Languages) | |
| Σ | 0..1 | boolean | Controls behaviour of the value set expand operation when value sets are too large to be completely expanded | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Explanation of Benefit resource Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| 0..* | Identifier | Business Identifier | ||
| ?!Σ | 0..1 | code | active | cancelled | draft | entered-in-error ExplanationOfBenefitStatus (Required) | |
| 0..1 | CodeableConcept | Type or discipline Example Claim Type Codes (Required) | ||
| 0..* | CodeableConcept | Finer grained claim type information Example Claim SubType Codes (Example) | ||
| 0..1 | Reference(Patient) | The subject of the Products and Services | ||
| 0..1 | Period | Period for charge submission | ||
| 0..1 | dateTime | Creation date | ||
| 0..1 | Reference(Practitioner) | Author | ||
| 0..1 | Reference(Organization) | Insurer responsible for the EOB | ||
| 0..1 | Reference(Practitioner) | Responsible provider for the claim | ||
| 0..1 | Reference(Organization) | Responsible organization for the claim | ||
| 0..1 | Reference(ReferralRequest) | Treatment Referral | ||
| 0..1 | Reference(Location) | Servicing Facility | ||
| 0..1 | Reference(Claim) | Claim reference | ||
| 0..1 | Reference(ClaimResponse) | Claim response reference | ||
| 0..1 | CodeableConcept | complete | error | partial Claim Processing Codes (Example) | ||
| 0..1 | string | Disposition Message | ||
| 0..* | BackboneElement | Related Claims which may be revelant to processing this claim | ||
| 0..1 | Reference(Claim) | Reference to the related claim | ||
| 0..1 | CodeableConcept | How the reference claim is related Example Related Claim Relationship Codes (Example) | ||
| 0..1 | Identifier | Related file or case reference | ||
| 0..1 | Reference(MedicationRequest | VisionPrescription) | Prescription authorizing services or products | ||
| 0..1 | Reference(MedicationRequest) | Original prescription if superceded by fulfiller | ||
| 0..1 | BackboneElement | Party to be paid any benefits payable | ||
| 0..1 | CodeableConcept | Type of party: Subscriber, Provider, other Claim Payee Type Codes (Example) | ||
| 0..1 | CodeableConcept | organization | patient | practitioner | relatedperson PayeeResourceType (Required) | ||
| 0..1 | Reference(Practitioner | Organization | Patient | RelatedPerson) | Party to receive the payable | ||
| 0..* | BackboneElement | Exceptions, special considerations, the condition, situation, prior or concurrent issues | ||
| 1..1 | positiveInt | Information instance identifier | ||
| 1..1 | CodeableConcept | General class of information Claim Information Category Codes (Example) | ||
| 0..1 | CodeableConcept | Type of information Exception Codes (Example) | ||
| 0..1 | When it occurred | |||
| date | ||||
| Period | ||||
| 0..1 | Additional Data or supporting information | |||
| string | ||||
| Quantity | ||||
| Attachment | ||||
| Reference(Any) | ||||
| 0..1 | Coding | Reason associated with the information Missing Tooth Reason Codes (Example) | ||
| 0..* | BackboneElement | Care Team members | ||
| 1..1 | positiveInt | Number to covey order of careteam | ||
| 1..1 | Reference(Practitioner | Organization) | Member of the Care Team | ||
| 0..1 | boolean | Billing practitioner | ||
| 0..1 | CodeableConcept | Role on the team Claim Care Team Role Codes (Example) | ||
| 0..1 | CodeableConcept | Type, classification or Specialization Example Provider Qualification Codes (Example) | ||
| 0..* | BackboneElement | List of Diagnosis | ||
| 1..1 | positiveInt | Number to covey order of diagnosis | ||
| 1..1 | Patient's diagnosis ICD-10 Codes (Example) | |||
| CodeableConcept | ||||
| Reference(Condition) | ||||
| 0..* | CodeableConcept | Timing or nature of the diagnosis Example Diagnosis Type Codes (Example) | ||
| 0..1 | CodeableConcept | Package billing code Example Diagnosis Related Group Codes (Example) | ||
| 0..* | BackboneElement | Procedures performed | ||
| 1..1 | positiveInt | Procedure sequence for reference | ||
| 0..1 | dateTime | When the procedure was performed | ||
| 1..1 | Patient's list of procedures performed ICD-10 Procedure Codes (Example) | |||
| CodeableConcept | ||||
| Reference(Procedure) | ||||
| 0..1 | positiveInt | Precedence (primary, secondary, etc.) | ||
| 0..1 | BackboneElement | Insurance or medical plan | ||
| 0..1 | Reference(Coverage) | Insurance information | ||
| 0..* | string | Pre-Authorization/Determination Reference | ||
| 0..1 | BackboneElement | Details of an accident | ||
| 0..1 | date | When the accident occurred | ||
| 0..1 | CodeableConcept | The nature of the accident ActIncidentCode (Required) | ||
| 0..1 | Accident Place | |||
| Address | ||||
| Reference(Location) | ||||
| 0..1 | Period | Period unable to work | ||
| 0..1 | Period | Period in hospital | ||
| 0..* | BackboneElement | Goods and Services | ||
| 1..1 | positiveInt | Service instance | ||
| 0..* | positiveInt | Applicable careteam members | ||
| 0..* | positiveInt | Applicable diagnoses | ||
| 0..* | positiveInt | Applicable procedures | ||
| 0..* | positiveInt | Applicable exception and supporting information | ||
| 0..1 | CodeableConcept | Revenue or cost center code Example Revenue Center Codes (Example) | ||
| 0..1 | CodeableConcept | Type of service or product Benefit SubCategory Codes (Example) | ||
| 0..1 | CodeableConcept | Billing Code USCLS Codes (Example) | ||
| 0..* | CodeableConcept | Service/Product billing modifiers Modifier type Codes (Example) | ||
| 0..* | CodeableConcept | Program specific reason for item inclusion Example Program Reason Codes (Example) | ||
| 0..1 | Date or dates of Service | |||
| date | ||||
| Period | ||||
| 0..1 | Place of service Example Service Place Codes (Example) | |||
| CodeableConcept | ||||
| Address | ||||
| Reference(Location) | ||||
| 0..1 | SimpleQuantity | Count of Products or Services | ||
| 0..1 | Money | Fee, charge or cost per point | ||
| 0..1 | decimal | Price scaling factor | ||
| 0..1 | Money | Total item cost | ||
| 0..* | Reference(Device) | Unique Device Identifier | ||
| 0..1 | CodeableConcept | Service Location Oral Site Codes (Example) | ||
| 0..* | CodeableConcept | Service Sub-location Surface Codes (Example) | ||
| 0..* | Reference(Encounter) | Encounters related to this billed item | ||
| 0..* | positiveInt | List of note numbers which apply | ||
| 0..* | BackboneElement | Adjudication details | ||
| 1..1 | CodeableConcept | Adjudication category such as co-pay, eligible, benefit, etc. Adjudication Value Codes (Example) | ||
| 0..1 | CodeableConcept | Explanation of Adjudication outcome Adjudication Reason Codes (Example) | ||
| 0..1 | Money | Monetary amount | ||
| 0..1 | decimal | Non-monitory value | ||
| 0..* | BackboneElement | Additional items | ||
| 1..1 | positiveInt | Service instance | ||
| 1..1 | CodeableConcept | Group or type of product or service ActInvoiceGroupCode (Required) | ||
| 0..1 | CodeableConcept | Revenue or cost center code Example Revenue Center Codes (Example) | ||
| 0..1 | CodeableConcept | Type of service or product Benefit SubCategory Codes (Example) | ||
| 0..1 | CodeableConcept | Billing Code USCLS Codes (Example) | ||
| 0..* | CodeableConcept | Service/Product billing modifiers Modifier type Codes (Example) | ||
| 0..* | CodeableConcept | Program specific reason for item inclusion Example Program Reason Codes (Example) | ||
| 0..1 | SimpleQuantity | Count of Products or Services | ||
| 0..1 | Money | Fee, charge or cost per point | ||
| 0..1 | decimal | Price scaling factor | ||
| 0..1 | Money | Total additional item cost | ||
| 0..* | Reference(Device) | Unique Device Identifier | ||
| 0..* | positiveInt | List of note numbers which apply | ||
| 0..* | see adjudication | Detail level adjudication details | ||
| 0..* | BackboneElement | Additional items | ||
| 1..1 | positiveInt | Service instance | ||
| 1..1 | CodeableConcept | Type of product or service ActInvoiceGroupCode (Required) | ||
| 0..1 | CodeableConcept | Revenue or cost center code Example Revenue Center Codes (Example) | ||
| 0..1 | CodeableConcept | Type of service or product Benefit SubCategory Codes (Example) | ||
| 0..1 | CodeableConcept | Billing Code USCLS Codes (Example) | ||
| 0..* | CodeableConcept | Service/Product billing modifiers Modifier type Codes (Example) | ||
| 0..* | CodeableConcept | Program specific reason for item inclusion Example Program Reason Codes (Example) | ||
| 0..1 | SimpleQuantity | Count of Products or Services | ||
| 0..1 | Money | Fee, charge or cost per point | ||
| 0..1 | decimal | Price scaling factor | ||
| 0..1 | Money | Net additional item cost | ||
| 0..* | Reference(Device) | Unique Device Identifier | ||
| 0..* | positiveInt | List of note numbers which apply | ||
| 0..* | see adjudication | Language if different from the resource | ||
| 0..* | BackboneElement | Insurer added line items | ||
| 0..* | positiveInt | Service instances | ||
| 0..1 | CodeableConcept | Revenue or cost center code Example Revenue Center Codes (Example) | ||
| 0..1 | CodeableConcept | Type of service or product Benefit SubCategory Codes (Example) | ||
| 0..1 | CodeableConcept | Billing Code USCLS Codes (Example) | ||
| 0..* | CodeableConcept | Service/Product billing modifiers Modifier type Codes (Example) | ||
| 0..1 | Money | Professional fee or Product charge | ||
| 0..* | positiveInt | List of note numbers which apply | ||
| 0..* | see adjudication | Added items adjudication | ||
| 0..* | BackboneElement | Added items details | ||
| 0..1 | CodeableConcept | Revenue or cost center code Example Revenue Center Codes (Example) | ||
| 0..1 | CodeableConcept | Type of service or product Benefit SubCategory Codes (Example) | ||
| 0..1 | CodeableConcept | Billing Code USCLS Codes (Example) | ||
| 0..* | CodeableConcept | Service/Product billing modifiers Modifier type Codes (Example) | ||
| 0..1 | Money | Professional fee or Product charge | ||
| 0..* | positiveInt | List of note numbers which apply | ||
| 0..* | see adjudication | Added items detail adjudication | ||
| 0..1 | Money | Total Cost of service from the Claim | ||
| 0..1 | Money | Unallocated deductable | ||
| 0..1 | Money | Total benefit payable for the Claim | ||
| 0..1 | BackboneElement | Payment (if paid) | ||
| 0..1 | CodeableConcept | Partial or Complete Example Payment Type Codes (Example) | ||
| 0..1 | Money | Payment adjustment for non-Claim issues | ||
| 0..1 | CodeableConcept | Explanation for the non-claim adjustment Payment Adjustment Reason Codes (Example) | ||
| 0..1 | date | Expected date of Payment | ||
| 0..1 | Money | Payable amount after adjustment | ||
| 0..1 | Identifier | Identifier of the payment instrument | ||
| 0..1 | CodeableConcept | Printed Form Identifier Form Codes (Example) | ||
| 0..* | BackboneElement | Processing notes | ||
| 0..1 | positiveInt | Sequence number for this note | ||
| 0..1 | CodeableConcept | display | print | printoper NoteType (Required) | ||
| 0..1 | string | Note explanitory text | ||
| 0..1 | CodeableConcept | Language if different from the resource Common Languages (Extensible but limited to All Languages) | ||
| 0..* | BackboneElement | Balance by Benefit Category | ||
| 1..1 | CodeableConcept | Type of services covered Benefit Category Codes (Example) | ||
| 0..1 | CodeableConcept | Detailed services covered within the type Benefit SubCategory Codes (Example) | ||
| 0..1 | boolean | Excluded from the plan | ||
| 0..1 | string | Short name for the benefit | ||
| 0..1 | string | Description of the benefit or services covered | ||
| 0..1 | CodeableConcept | In or out of network Network Type Codes (Example) | ||
| 0..1 | CodeableConcept | Individual or family Unit Type Codes (Example) | ||
| 0..1 | CodeableConcept | Annual or lifetime Benefit Term Codes (Example) | ||
| 0..* | BackboneElement | Benefit Summary | ||
| 1..1 | CodeableConcept | Deductable, visits, benefit amount Benefit Type Codes (Example) | ||
| 0..1 | Benefits allowed | |||
| unsignedInt | ||||
| string | ||||
| Money | ||||
| 0..1 | Benefits used | |||
| unsignedInt | ||||
| Money | ||||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | Information about patient's relatives, relevant for patient + Can only have estimatedAge if age[x] is present + Not Done Reason can only be specified if NotDone is "true" + Can have age[x] or born[x], but not both Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..* | Identifier | External Id(s) for this record | |
| Σ | 0..* | Reference(PlanDefinition | Questionnaire) | Instantiates protocol or definition | |
| ?!Σ | 1..1 | code | partial | completed | entered-in-error | health-unknown FamilyHistoryStatus (Required) | |
| ?!Σ | 0..1 | boolean | The taking of a family member's history did not occur | |
| ΣI | 0..1 | CodeableConcept | subject-unknown | withheld | unable-to-obtain | deferred FamilyHistoryNotDoneReason (Example) | |
| Σ | 1..1 | Reference(Patient) | Patient history is about | |
| Σ | 0..1 | dateTime | When history was captured/updated | |
| Σ | 0..1 | string | The family member described | |
| Σ | 1..1 | CodeableConcept | Relationship to the subject FamilyMember (Example) | |
| Σ | 0..1 | code | male | female | other | unknown AdministrativeGender (Required) | |
| I | 0..1 | (approximate) date of birth | ||
| Period | ||||
| date | ||||
| string | ||||
| ΣI | 0..1 | (approximate) age | ||
| Age | ||||
| Range | ||||
| string | ||||
| ?!ΣI | 0..1 | boolean | Age is estimated? | |
| Σ | 0..1 | Dead? How old/when? | ||
| boolean | ||||
| Age | ||||
| Range | ||||
| date | ||||
| string | ||||
| Σ | 0..* | CodeableConcept | Why was family member history performed? SNOMED CT Clinical Findings (Example) | |
| Σ | 0..* | Reference(Condition | Observation | AllergyIntolerance | QuestionnaireResponse) | Why was family member history performed? | |
| 0..* | Annotation | General note about related person | ||
| 0..* | BackboneElement | Condition that the related person had | ||
| 1..1 | CodeableConcept | Condition suffered by relation Condition/Problem/Diagnosis Codes (Example) | ||
| 0..1 | CodeableConcept | deceased | permanent disability | etc. Condition Outcome Codes (Example) | ||
| 0..1 | When condition first manifested | |||
| Age | ||||
| Range | ||||
| Period | ||||
| string | ||||
| 0..* | Annotation | Extra information about condition | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Key information to flag to healthcare providers Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | Business identifier | |
| ?!Σ | 1..1 | code | active | inactive | entered-in-error FlagStatus (Required) | |
| Σ | 0..1 | CodeableConcept | Clinical, administrative, etc. Flag Category (Example) | |
| Σ | 1..1 | CodeableConcept | Coded or textual message to display to user Flag Code (Example) | |
| Σ | 1..1 | Reference(Patient | Location | Group | Organization | Practitioner | PlanDefinition | Medication | Procedure) | Who/What is flag about? | |
| Σ | 0..1 | Period | Time period when flag is active | |
| Σ | 0..1 | Reference(Encounter) | Alert relevant during encounter | |
| Σ | 0..1 | Reference(Device | Organization | Patient | Practitioner) | Flag creator | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Describes the intended objective(s) for a patient, group or organization Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| 0..* | Identifier | External Ids for this goal | ||
| ?!Σ | 1..1 | code | proposed | accepted | planned | in-progress | on-target | ahead-of-target | behind-target | sustaining | achieved | on-hold | cancelled | entered-in-error | rejected GoalStatus (Required) | |
| Σ | 0..* | CodeableConcept | E.g. Treatment, dietary, behavioral, etc. GoalCategory (Example) | |
| Σ | 0..1 | CodeableConcept | high-priority | medium-priority | low-priority GoalPriority (Preferred) | |
| Σ | 1..1 | CodeableConcept | Code or text describing goal SNOMED CT Clinical Findings (Example) | |
| Σ | 0..1 | Reference(Patient | Group | Organization) | Who this goal is intended for | |
| Σ | 0..1 | When goal pursuit begins GoalStartEvent (Example) | ||
| date | ||||
| CodeableConcept | ||||
| I | 0..1 | BackboneElement | Target outcome for the goal + Goal.target.measure is required if Goal.target.detail is populated | |
| ΣI | 0..1 | CodeableConcept | The parameter whose value is being tracked LOINC Codes (Example) | |
| ΣI | 0..1 | The target value to be achieved | ||
| Quantity | ||||
| Range | ||||
| CodeableConcept | ||||
| Σ | 0..1 | Reach goal on or before | ||
| date | ||||
| Duration | ||||
| Σ | 0..1 | date | When goal status took effect | |
| 0..1 | string | Reason for current status | ||
| Σ | 0..1 | Reference(Patient | Practitioner | RelatedPerson) | Who's responsible for creating Goal? | |
| 0..* | Reference(Condition | Observation | MedicationStatement | NutritionOrder | ProcedureRequest | RiskAssessment) | Issues addressed by this goal | ||
| 0..* | Annotation | Comments about the goal | ||
| 0..* | CodeableConcept | What result was achieved regarding the goal? SNOMED CT Clinical Findings (Example) | ||
| 0..* | Reference(Observation) | Observation that resulted from goal | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Definition of an graph of resources Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | uri | Logical URI to reference this graph definition (globally unique) | |
| Σ | 0..1 | string | Business version of the graph definition | |
| Σ | 1..1 | string | Name for this graph definition (computer friendly) | |
| ?!Σ | 1..1 | code | draft | active | retired | unknown PublicationStatus (Required) | |
| ?!Σ | 0..1 | boolean | For testing purposes, not real usage | |
| Σ | 0..1 | dateTime | Date this was last changed | |
| Σ | 0..1 | string | Name of the publisher (organization or individual) | |
| Σ | 0..* | ContactDetail | Contact details for the publisher | |
| 0..1 | markdown | Natural language description of the graph definition | ||
| Σ | 0..* | UsageContext | Context the content is intended to support | |
| Σ | 0..* | CodeableConcept | Intended jurisdiction for graph definition (if applicable) Jurisdiction ValueSet (Extensible) | |
| 0..1 | markdown | Why this graph definition is defined | ||
| 1..1 | code | Type of resource at which the graph starts ResourceType (Required) | ||
| 0..1 | uri | Profile on base resource | ||
| 0..* | BackboneElement | Links this graph makes rules about | ||
| 1..1 | string | Path in the resource that contains the link | ||
| 0..1 | string | Which slice (if profiled) | ||
| 0..1 | integer | Minimum occurrences for this link | ||
| 0..1 | string | Maximum occurrences for this link | ||
| 0..1 | string | Why this link is specified | ||
| 1..* | BackboneElement | Potential target for the link | ||
| 1..1 | code | Type of resource this link refers to ResourceType (Required) | ||
| 0..1 | uri | Profile for the target resource | ||
| 0..* | BackboneElement | Compartment Consistency Rules | ||
| 1..1 | code | Identifies the compartment CompartmentType (Required) | ||
| 1..1 | code | identical | matching | different | custom GraphCompartmentRule (Required) | ||
| 0..1 | string | Custom rule, as a FHIRPath expression | ||
| 0..1 | string | Documentation for FHIRPath expression | ||
| 0..* | see link | Additional links from target resource | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | Group of multiple entities + Can only have members if group is "actual" Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..* | Identifier | Unique id | |
| Σ | 0..1 | boolean | Whether this group's record is in active use | |
| Σ | 1..1 | code | person | animal | practitioner | device | medication | substance GroupType (Required) | |
| ΣI | 1..1 | boolean | Descriptive or actual | |
| Σ | 0..1 | CodeableConcept | Kind of Group members | |
| Σ | 0..1 | string | Label for Group | |
| Σ | 0..1 | unsignedInt | Number of members | |
| 0..* | BackboneElement | Trait of group members | ||
| 1..1 | CodeableConcept | Kind of characteristic | ||
| 1..1 | Value held by characteristic | |||
| CodeableConcept | ||||
| boolean | ||||
| Quantity | ||||
| Range | ||||
| ?! | 1..1 | boolean | Group includes or excludes | |
| 0..1 | Period | Period over which characteristic is tested | ||
| I | 0..* | BackboneElement | Who or what is in group | |
| 1..1 | Reference(Patient | Practitioner | Device | Medication | Substance) | Reference to the group member | ||
| 0..1 | Period | Period member belonged to the group | ||
| 0..1 | boolean | If member is no longer in group | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | The formal response to a guidance request Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | id | The id of the request associated with this response, if any | |
| Σ | 0..1 | Identifier | Business identifier | |
| Σ | 1..1 | Reference(ServiceDefinition) | A reference to a knowledge module | |
| ?!Σ | 1..1 | code | success | data-requested | data-required | in-progress | failure | entered-in-error GuidanceResponseStatus (Required) | |
| 0..1 | Reference(Patient | Group) | Patient the request was performed for | ||
| 0..1 | Reference(Encounter | EpisodeOfCare) | Encounter or Episode during which the response was returned | ||
| 0..1 | dateTime | When the guidance response was processed | ||
| 0..1 | Reference(Device) | Device returning the guidance | ||
| 0..1 | Reason for the response | |||
| CodeableConcept | ||||
| Reference(Any) | ||||
| 0..* | Annotation | Additional notes about the response | ||
| 0..* | Reference(OperationOutcome) | Messages resulting from the evaluation of the artifact or artifacts | ||
| 0..1 | Reference(Parameters) | The output parameters of the evaluation, if any | ||
| 0..1 | Reference(CarePlan | RequestGroup) | Proposed actions, if any | ||
| 0..* | DataRequirement | Additional required data | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | The details of a healthcare service available at a location Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | External identifiers for this item | |
| ?!Σ | 0..1 | boolean | Whether this healthcareservice is in active use | |
| Σ | 0..1 | Reference(Organization) | Organization that provides this service | |
| Σ | 0..1 | CodeableConcept | Broad category of service being performed or delivered ServiceCategory (Example) | |
| Σ | 0..* | CodeableConcept | Type of service that may be delivered or performed ServiceType (Example) | |
| Σ | 0..* | CodeableConcept | Specialties handled by the HealthcareService Practice Setting Code Value Set (Preferred) | |
| Σ | 0..* | Reference(Location) | Location(s) where service may be provided | |
| Σ | 0..1 | string | Description of service as presented to a consumer while searching | |
| Σ | 0..1 | string | Additional description and/or any specific issues not covered elsewhere | |
| 0..1 | string | Extra details about the service that can't be placed in the other fields | ||
| Σ | 0..1 | Attachment | Facilitates quick identification of the service | |
| 0..* | ContactPoint | Contacts related to the healthcare service | ||
| 0..* | Reference(Location) | Location(s) service is inteded for/available to | ||
| 0..* | CodeableConcept | Conditions under which service is available/offered ServiceProvisionConditions (Example) | ||
| 0..1 | CodeableConcept | Specific eligibility requirements required to use the service | ||
| 0..1 | string | Describes the eligibility conditions for the service | ||
| 0..* | string | Program Names that categorize the service | ||
| 0..* | CodeableConcept | Collection of characteristics (attributes) | ||
| 0..* | CodeableConcept | Ways that the service accepts referrals ReferralMethod (Example) | ||
| 0..1 | boolean | If an appointment is required for access to this service | ||
| 0..* | BackboneElement | Times the Service Site is available | ||
| 0..* | code | mon | tue | wed | thu | fri | sat | sun DaysOfWeek (Required) | ||
| 0..1 | boolean | Always available? e.g. 24 hour service | ||
| 0..1 | time | Opening time of day (ignored if allDay = true) | ||
| 0..1 | time | Closing time of day (ignored if allDay = true) | ||
| 0..* | BackboneElement | Not available during this time due to provided reason | ||
| 1..1 | string | Reason presented to the user explaining why time not available | ||
| 0..1 | Period | Service not availablefrom this date | ||
| 0..1 | string | Description of availability exceptions | ||
| 0..* | Reference(Endpoint) | Technical endpoints providing access to services operated for the location | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Key Object Selection Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | Identifier | SOP Instance UID | |
| Σ | 1..1 | Reference(Patient) | Patient of the selected objects | |
| Σ | 0..1 | dateTime | Time when the selection of instances was made | |
| Σ | 0..1 | Reference(Practitioner | Device | Organization | Patient | RelatedPerson) | Author (human or machine) | |
| Σ | 0..1 | string | Description text | |
| Σ | 1..* | BackboneElement | Study identity of the selected instances | |
| Σ | 1..1 | oid | Study instance UID | |
| Σ | 0..1 | Reference(ImagingStudy) | Reference to ImagingStudy | |
| Σ | 0..* | Reference(Endpoint) | Study access service endpoint | |
| Σ | 1..* | BackboneElement | Series identity of the selected instances | |
| Σ | 1..1 | oid | Series instance UID | |
| Σ | 0..* | Reference(Endpoint) | Series access endpoint | |
| Σ | 1..* | BackboneElement | The selected instance | |
| Σ | 1..1 | oid | SOP class UID of instance | |
| Σ | 1..1 | oid | Selected instance UID | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | A set of images produced in single study (one or more series of references images) Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 1..1 | oid | Formal DICOM identifier for the study | |
| Σ | 0..1 | Identifier | Related workflow identifier ("Accession Number") | |
| Σ | 0..* | Identifier | Other identifiers for the study | |
| Σ | 0..1 | code | ONLINE | OFFLINE | NEARLINE | UNAVAILABLE InstanceAvailability (Required) | |
| Σ | 0..* | Coding | All series modality if actual acquisition modalities Acquisition Modality Codes (Extensible) | |
| Σ | 1..1 | Reference(Patient) | Who the images are of | |
| Σ | 0..1 | Reference(Encounter | EpisodeOfCare) | Originating context | |
| Σ | 0..1 | dateTime | When the study was started | |
| Σ | 0..* | Reference(ReferralRequest | CarePlan | ProcedureRequest) | Request fulfilled | |
| Σ | 0..1 | Reference(Practitioner) | Referring physician | |
| Σ | 0..* | Reference(Practitioner) | Who interpreted images | |
| Σ | 0..* | Reference(Endpoint) | Study access endpoint | |
| Σ | 0..1 | unsignedInt | Number of Study Related Series | |
| Σ | 0..1 | unsignedInt | Number of Study Related Instances | |
| Σ | 0..* | Reference(Procedure) | The performed Procedure reference | |
| Σ | 0..* | CodeableConcept | The performed procedure code Procedure Codes (SNOMED CT) (Example) | |
| Σ | 0..1 | CodeableConcept | Why the study was requested Procedure Reason Codes (Example) | |
| Σ | 0..1 | string | Institution-generated description | |
| Σ | 0..* | BackboneElement | Each study has one or more series of instances | |
| Σ | 1..1 | oid | Formal DICOM identifier for this series | |
| Σ | 0..1 | unsignedInt | Numeric identifier of this series | |
| Σ | 1..1 | Coding | The modality of the instances in the series Acquisition Modality Codes (Extensible) | |
| Σ | 0..1 | string | A short human readable summary of the series | |
| Σ | 0..1 | unsignedInt | Number of Series Related Instances | |
| Σ | 0..1 | code | ONLINE | OFFLINE | NEARLINE | UNAVAILABLE InstanceAvailability (Required) | |
| Σ | 0..* | Reference(Endpoint) | Series access endpoint | |
| Σ | 0..1 | Coding | Body part examined SNOMED CT Body Structures (Example) | |
| Σ | 0..1 | Coding | Body part laterality Laterality (Example) | |
| Σ | 0..1 | dateTime | When the series started | |
| Σ | 0..* | Reference(Practitioner) | Who performed the series | |
| 0..* | BackboneElement | A single SOP instance from the series | ||
| 1..1 | oid | Formal DICOM identifier for this instance | ||
| 0..1 | unsignedInt | The number of this instance in the series | ||
| 1..1 | oid | DICOM class type | ||
| 0..1 | string | Description of instance | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | Immunization event information + If immunization was administered (notGiven=false) then explanation.reasonNotGiven SHALL be absent. + If immunization was not administered (notGiven=true) then there SHALL be no reaction nor explanation.reason present Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| 0..* | Identifier | Business identifier | ||
| ?!Σ | 1..1 | code | completed | entered-in-error Immunization Status Codes (Required) | |
| ?!Σ | 1..1 | boolean | Flag for whether immunization was given | |
| 1..1 | CodeableConcept | Vaccine product administered Vaccine Administered Value Set (Example) | ||
| 1..1 | Reference(Patient) | Who was immunized | ||
| 0..1 | Reference(Encounter) | Encounter administered as part of | ||
| 0..1 | dateTime | Vaccination administration date | ||
| 1..1 | boolean | Indicates context the data was recorded in | ||
| 0..1 | CodeableConcept | Indicates the source of a secondarily reported record Immunization Origin Codes (Example) | ||
| 0..1 | Reference(Location) | Where vaccination occurred | ||
| 0..1 | Reference(Organization) | Vaccine manufacturer | ||
| 0..1 | string | Vaccine lot number | ||
| 0..1 | date | Vaccine expiration date | ||
| 0..1 | CodeableConcept | Body site vaccine was administered Codes for Immunization Site of Administration (Example) | ||
| 0..1 | CodeableConcept | How vaccine entered body Immunization Route Codes (Example) | ||
| 0..1 | SimpleQuantity | Amount of vaccine administered | ||
| Σ | 0..* | BackboneElement | Who performed event | |
| Σ | 0..1 | CodeableConcept | What type of performance was done Immunization Role Codes (Extensible) | |
| Σ | 1..1 | Reference(Practitioner) | Individual who was performing | |
| Σ | 0..* | Annotation | Vaccination notes | |
| 0..1 | BackboneElement | Administration/non-administration reasons | ||
| 0..* | CodeableConcept | Why immunization occurred Immunization Reason Codes (Example) | ||
| 0..* | CodeableConcept | Why immunization did not occur Immunization Reasons for Not Immunizing Codes (Example) | ||
| 0..* | BackboneElement | Details of a reaction that follows immunization | ||
| 0..1 | dateTime | When reaction started | ||
| 0..1 | Reference(Observation) | Additional information on reaction | ||
| 0..1 | boolean | Indicates self-reported reaction | ||
| 0..* | BackboneElement | What protocol was followed | ||
| 0..1 | positiveInt | Dose number within series | ||
| 0..1 | string | Details of vaccine protocol | ||
| 0..1 | Reference(Organization) | Who is responsible for protocol | ||
| 0..1 | string | Name of vaccine series | ||
| 0..1 | positiveInt | Recommended number of doses for immunity | ||
| 1..* | CodeableConcept | Disease immunized against Vaccination Protocol Dose Target Codes (Example) | ||
| 1..1 | CodeableConcept | Indicates if dose counts towards immunity Vaccination Protocol Dose Status codes (Example) | ||
| 0..1 | CodeableConcept | Why dose does (not) count Vaccination Protocol Dose Status Reason codes (Example) | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Guidance or advice relating to an immunization Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | Business identifier | |
| Σ | 1..1 | Reference(Patient) | Who this profile is for | |
| ΣI | 1..* | BackboneElement | Vaccine administration recommendations + One of vaccineCode or targetDisease SHALL be present | |
| Σ | 1..1 | dateTime | Date recommendation created | |
| Σ | 0..1 | CodeableConcept | Vaccine recommendation applies to Vaccine Administered Value Set (Example) | |
| Σ | 0..1 | CodeableConcept | Disease to be immunized against Immunization Recommendation Target Disease Codes (Example) | |
| Σ | 0..1 | positiveInt | Recommended dose number | |
| Σ | 1..1 | CodeableConcept | Vaccine administration status Immunization Recommendation Status Codes (Example) | |
| 0..* | BackboneElement | Dates governing proposed immunization | ||
| 1..1 | CodeableConcept | Type of date Immunization Recommendation Date Criterion Codes (Example) | ||
| 1..1 | dateTime | Recommended date | ||
| 0..1 | BackboneElement | Protocol used by recommendation | ||
| 0..1 | positiveInt | Dose number within sequence | ||
| 0..1 | string | Protocol details | ||
| 0..1 | Reference(Organization) | Who is responsible for protocol | ||
| 0..1 | string | Name of vaccination series | ||
| 0..* | Reference(Immunization) | Past immunizations supporting recommendation | ||
| 0..* | Reference(Observation | AllergyIntolerance) | Patient observations supporting recommendation | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | A set of rules about how FHIR is used Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 1..1 | uri | Logical URI to reference this implementation guide (globally unique) | |
| Σ | 0..1 | string | Business version of the implementation guide | |
| Σ | 1..1 | string | Name for this implementation guide (computer friendly) | |
| ?!Σ | 1..1 | code | draft | active | retired | unknown PublicationStatus (Required) | |
| ?!Σ | 0..1 | boolean | For testing purposes, not real usage | |
| Σ | 0..1 | dateTime | Date this was last changed | |
| Σ | 0..1 | string | Name of the publisher (organization or individual) | |
| Σ | 0..* | ContactDetail | Contact details for the publisher | |
| 0..1 | markdown | Natural language description of the implementation guide | ||
| Σ | 0..* | UsageContext | Context the content is intended to support | |
| Σ | 0..* | CodeableConcept | Intended jurisdiction for implementation guide (if applicable) Jurisdiction ValueSet (Extensible) | |
| 0..1 | markdown | Use and/or publishing restrictions | ||
| Σ | 0..1 | id | FHIR Version this Implementation Guide targets | |
| Σ | 0..* | BackboneElement | Another Implementation guide this depends on | |
| Σ | 1..1 | code | reference | inclusion GuideDependencyType (Required) | |
| Σ | 1..1 | uri | Where to find dependency | |
| Σ | 0..* | BackboneElement | Group of resources as used in .page.package | |
| Σ | 1..1 | string | Name used .page.package | |
| 0..1 | string | Human readable text describing the package | ||
| Σ | 1..* | BackboneElement | Resource in the implementation guide | |
| Σ | 1..1 | boolean | If not an example, has its normal meaning | |
| Σ | 0..1 | string | Human Name for the resource | |
| 0..1 | string | Reason why included in guide | ||
| 0..1 | string | Short code to identify the resource | ||
| Σ | 1..1 | Location of the resource | ||
| uri | ||||
| Reference(Any) | ||||
| 0..1 | Reference(StructureDefinition) | Resource this is an example of (if applicable) | ||
| Σ | 0..* | BackboneElement | Profiles that apply globally | |
| Σ | 1..1 | code | Type this profiles applies to ResourceType (Required) | |
| Σ | 1..1 | Reference(StructureDefinition) | Profile that all resources must conform to | |
| 0..* | uri | Image, css, script, etc. | ||
| Σ | 0..1 | BackboneElement | Page/Section in the Guide | |
| Σ | 1..1 | uri | Where to find that page | |
| Σ | 1..1 | string | Short title shown for navigational assistance | |
| Σ | 1..1 | code | page | example | list | include | directory | dictionary | toc | resource GuidePageKind (Required) | |
| 0..* | code | Kind of resource to include in the list ResourceType (Required) | ||
| 0..* | string | Name of package to include | ||
| 0..1 | code | Format of the page (e.g. html, markdown, etc.) MimeType (Required) | ||
| 0..* | see page | Nested Pages / Sections | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Represents a library of quality improvement components Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | uri | Logical URI to reference this library (globally unique) | |
| Σ | 0..* | Identifier | Additional identifier for the library | |
| Σ | 0..1 | string | Business version of the library | |
| Σ | 0..1 | string | Name for this library (computer friendly) | |
| Σ | 0..1 | string | Name for this library (human friendly) | |
| ?!Σ | 1..1 | code | draft | active | retired | unknown PublicationStatus (Required) | |
| ?!Σ | 0..1 | boolean | For testing purposes, not real usage | |
| Σ | 1..1 | CodeableConcept | logic-library | model-definition | asset-collection | module-definition LibraryType (Extensible) | |
| Σ | 0..1 | dateTime | Date this was last changed | |
| Σ | 0..1 | string | Name of the publisher (organization or individual) | |
| Σ | 0..1 | markdown | Natural language description of the library | |
| 0..1 | markdown | Why this library is defined | ||
| 0..1 | string | Describes the clinical usage of the library | ||
| 0..1 | date | When the library was approved by publisher | ||
| 0..1 | date | When the library was last reviewed | ||
| Σ | 0..1 | Period | When the library is expected to be used | |
| Σ | 0..* | UsageContext | Context the content is intended to support | |
| Σ | 0..* | CodeableConcept | Intended jurisdiction for library (if applicable) Jurisdiction ValueSet (Extensible) | |
| 0..* | CodeableConcept | E.g. Education, Treatment, Assessment, etc DefinitionTopic (Example) | ||
| 0..* | Contributor | A content contributor | ||
| Σ | 0..* | ContactDetail | Contact details for the publisher | |
| 0..1 | markdown | Use and/or publishing restrictions | ||
| 0..* | RelatedArtifact | Additional documentation, citations, etc. | ||
| 0..* | ParameterDefinition | Parameters defined by the library | ||
| 0..* | DataRequirement | What data is referenced by this library | ||
| 0..* | Attachment | Contents of the library, either embedded or referenced | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| ΣI | DomainResource | Links records for 'same' item + Must have at least two items Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..1 | boolean | Whether this linkage assertion is active or not | |
| Σ | 0..1 | Reference(Practitioner | Organization) | Who is responsible for linkages | |
| ΣI | 1..* | BackboneElement | Item to be linked | |
| Σ | 1..1 | code | source | alternate | historical LinkageType (Required) | |
| Σ | 1..1 | Reference() | Resource being linked | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | Information summarized from a list of other resources + The deleted flag can only be used if the mode of the list is "changes" + A list can only have an emptyReason if it is empty Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| 0..* | Identifier | Business identifier | ||
| ?!Σ | 1..1 | code | current | retired | entered-in-error ListStatus (Required) | |
| ?!Σ | 1..1 | code | working | snapshot | changes ListMode (Required) | |
| Σ | 0..1 | string | Descriptive name for the list | |
| Σ | 0..1 | CodeableConcept | What the purpose of this list is Example Use Codes for List (Example) | |
| Σ | 0..1 | Reference(Patient | Group | Device | Location) | If all resources have the same subject | |
| 0..1 | Reference(Encounter) | Context in which list created | ||
| Σ | 0..1 | dateTime | When the list was prepared | |
| Σ | 0..1 | Reference(Practitioner | Patient | Device) | Who and/or what defined the list contents (aka Author) | |
| 0..1 | CodeableConcept | What order the list has List Order Codes (Preferred) | ||
| 0..* | Annotation | Comments about the list | ||
| I | 0..* | BackboneElement | Entries in the list | |
| 0..1 | CodeableConcept | Status/Workflow information about this item Patient Medicine Change Types (Example) | ||
| ?!I | 0..1 | boolean | If this item is actually marked as deleted | |
| 0..1 | dateTime | When item added to list | ||
| 1..1 | Reference(Any) | Actual entry | ||
| I | 0..1 | CodeableConcept | Why list is empty List Empty Reasons (Preferred) | |
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Details and position information for a physical place Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..* | Identifier | Unique code or number identifying the location to its users | |
| ?!Σ | 0..1 | code | active | suspended | inactive LocationStatus (Required) | |
| Σ | 0..1 | Coding | The Operational status of the location (typically only for a bed/room) v2 Bed Status (Preferred) | |
| Σ | 0..1 | string | Name of the location as used by humans | |
| 0..* | string | A list of alternate names that the location is known as, or was known as in the past | ||
| Σ | 0..1 | string | Additional details about the location that could be displayed as further information to identify the location beyond its name | |
| ?!Σ | 0..1 | code | instance | kind LocationMode (Required) | |
| Σ | 0..1 | CodeableConcept | Type of function performed ServiceDeliveryLocationRoleType (Extensible) | |
| 0..* | ContactPoint | Contact details of the location | ||
| 0..1 | Address | Physical location | ||
| Σ | 0..1 | CodeableConcept | Physical form of the location LocationType (Example) | |
| 0..1 | BackboneElement | The absolute geographic location | ||
| 1..1 | decimal | Longitude with WGS84 datum | ||
| 1..1 | decimal | Latitude with WGS84 datum | ||
| 0..1 | decimal | Altitude with WGS84 datum | ||
| Σ | 0..1 | Reference(Organization) | Organization responsible for provisioning and upkeep | |
| 0..1 | Reference(Location) | Another Location this one is physically part of | ||
| 0..* | Reference(Endpoint) | Technical endpoints providing access to services operated for the location | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | A quality measure definition Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | uri | Logical URI to reference this measure (globally unique) | |
| Σ | 0..* | Identifier | Additional identifier for the measure | |
| Σ | 0..1 | string | Business version of the measure | |
| Σ | 0..1 | string | Name for this measure (computer friendly) | |
| Σ | 0..1 | string | Name for this measure (human friendly) | |
| ?!Σ | 1..1 | code | draft | active | retired | unknown PublicationStatus (Required) | |
| ?!Σ | 0..1 | boolean | For testing purposes, not real usage | |
| Σ | 0..1 | dateTime | Date this was last changed | |
| Σ | 0..1 | string | Name of the publisher (organization or individual) | |
| Σ | 0..1 | markdown | Natural language description of the measure | |
| 0..1 | markdown | Why this measure is defined | ||
| 0..1 | string | Describes the clinical usage of the measure | ||
| 0..1 | date | When the measure was approved by publisher | ||
| 0..1 | date | When the measure was last reviewed | ||
| Σ | 0..1 | Period | When the measure is expected to be used | |
| Σ | 0..* | UsageContext | Context the content is intended to support | |
| Σ | 0..* | CodeableConcept | Intended jurisdiction for measure (if applicable) Jurisdiction ValueSet (Extensible) | |
| 0..* | CodeableConcept | E.g. Education, Treatment, Assessment, etc DefinitionTopic (Example) | ||
| 0..* | Contributor | A content contributor | ||
| Σ | 0..* | ContactDetail | Contact details for the publisher | |
| 0..1 | markdown | Use and/or publishing restrictions | ||
| 0..* | RelatedArtifact | Additional documentation, citations, etc | ||
| 0..* | Reference(Library) | Logic used by the measure | ||
| Σ | 0..1 | markdown | Disclaimer for use of the measure or its referenced content | |
| Σ | 0..1 | CodeableConcept | proportion | ratio | continuous-variable | cohort MeasureScoring (Extensible) | |
| Σ | 0..1 | CodeableConcept | opportunity | all-or-nothing | linear | weighted CompositeMeasureScoring (Extensible) | |
| Σ | 0..* | CodeableConcept | process | outcome | structure | patient-reported-outcome | composite MeasureType (Extensible) | |
| Σ | 0..1 | string | How is risk adjustment applied for this measure | |
| Σ | 0..1 | string | How is rate aggregation performed for this measure | |
| Σ | 0..1 | markdown | Why does this measure exist | |
| Σ | 0..1 | markdown | Summary of clinical guidelines | |
| Σ | 0..1 | string | Improvement notation for the measure, e.g. higher score indicates better quality | |
| Σ | 0..* | markdown | Defined terms used in the measure documentation | |
| Σ | 0..1 | markdown | Additional guidance for implementers | |
| Σ | 0..1 | string | The measure set, e.g. Preventive Care and Screening | |
| 0..* | BackboneElement | Population criteria group | ||
| 1..1 | Identifier | Unique identifier | ||
| 0..1 | string | Short name | ||
| 0..1 | string | Summary description | ||
| 0..* | BackboneElement | Population criteria | ||
| 0..1 | Identifier | Unique identifier | ||
| 0..1 | CodeableConcept | initial-population | numerator | numerator-exclusion | denominator | denominator-exclusion | denominator-exception | measure-population | measure-population-exclusion | measure-observation MeasurePopulationType (Extensible) | ||
| 0..1 | string | Short name | ||
| 0..1 | string | The human readable description of this population criteria | ||
| 1..1 | string | The name of a valid referenced CQL expression (may be namespaced) that defines this population criteria | ||
| 0..* | BackboneElement | Stratifier criteria for the measure | ||
| 0..1 | Identifier | The identifier for the stratifier used to coordinate the reported data back to this stratifier | ||
| 0..1 | string | How the measure should be stratified | ||
| 0..1 | string | Path to the stratifier | ||
| 0..* | BackboneElement | What other data should be reported with the measure | ||
| 0..1 | Identifier | Identifier, unique within the measure | ||
| 0..* | CodeableConcept | supplemental-data | risk-adjustment-factor MeasureDataUsage (Extensible) | ||
| 0..1 | string | Expression describing additional data to be reported | ||
| 0..1 | string | Path to the supplemental data element | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| DomainResource | Results of a measure evaluation Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | |||
| Σ | 0..1 | Identifier | Additional identifier for the Report | |
| ?!Σ | 1..1 | code | complete | pending | error MeasureReportStatus (Required) | |
| Σ | 1..1 | code | individual | patient-list | summary MeasureReportType (Required) | |
| Σ | 1..1 | Reference(Measure) | What measure was evaluated | |
| Σ | 0..1 | Reference(Patient) | What patient the report is for | |
| Σ | 0..1 | dateTime | When the report was generated | |
| Σ | 0..1 | Reference(Organization) | Who is reporting the data | |
| Σ | 1..1 | Period | What period the report covers | |
| 0..* | BackboneElement | Measure results for each group | ||
| 1..1 | Identifier | What group of the measure | ||
| 0..* | BackboneElement | The populations in the group | ||
| Σ | 0..1 | Identifier | Population identifier as defined in the measure | |
| Σ | 0..1 | CodeableConcept | initial-population | numerator | numerator-exclusion | denominator | denominator-exclusion | denominator-exception | measure-population | measure-population-exclusion | measure-score MeasurePopulationType (Extensible) | |
| 0..1 | integer | Size of the population | ||
| 0..1 | Reference(List) | For patient-list reports, the patients in this population | ||
| Σ | 0..1 | decimal | What score this group achieved | |
| 0..* | BackboneElement | Stratification results | ||
| 0..1 | Identifier | What stratifier of the group | ||
| 0..* | BackboneElement | Stratum results, one for each unique value in the stratifier | ||
| 1..1 | string | The stratum value, e.g. male | ||
| 0..* | BackboneElement | Population results in this stratum | ||
| Σ | 0..1 | Identifier | Population identifier as defined in the measure | |
| Σ | 0..1 | CodeableConcept | initial-population | numerator | numerator-exclusion | denominator | denominator-exclusion | denominator-exception | measure-population | measure-population-exclusion | measure-score MeasurePopulationType (Extensible) | |
| 0..1 | integer | Size of the population | ||
| 0..1 | Reference(List) | For patient-list reports, the patients in this population | ||
| Σ | 0..1 | decimal | What score this stratum achieved | |
| 0..1 | Reference(Bundle) | What data was evaluated to produce the measure score | ||
| Documentation for this format |
| Name | Flags | Card. | Type | Description & Constraints |
|---|---|---|---|---|
| I | DomainResource | A photo, video, or audio recording acquired or used in healthcare. The actual content may be inline or provided by direct reference + Height can only be used for a photo or video + Width can only be used for a photo or video + Frames can only be used for a photo + Duration can only be used for an audio or a video Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension | ||
| Σ | 0..* | Identifier | Identifier(s) for the image | |
| Σ | 0..* | Reference(ProcedureRequest) | Procedure that caused this media to be created | |
| Σ | 1..1 | code | photo | video | audio DigitalMediaType (Required) | |
| Σ | 0..1 | CodeableConcept | The type of acquisition equipment/process Media SubType (Example) | |
| Σ | 0..1 | CodeableConcept | Imaging view, e.g. Lateral or Antero-posterior Media Collection View/Projection (Example) | |
| Σ | 0..1 | Reference(Patient | Practitioner | Group | Device | Specimen) | Who/What this Media is a record of | |
| Σ | 0..1 | Reference(Encounter | EpisodeOfCare) | Encounter / Episode associated with media | |
| Σ | 0..1 | When Media was collected | ||
| dateTime | ||||
| Period | ||||
| Σ | 0..1 | Reference(Practitioner) | The person who generated the image | |
| Σ | 0..* | CodeableConcept | Why was event performed? Procedure Reason Codes (Example) | |
| Σ | 0..1 | CodeableConcept | Body part in media SNOMED CT Body Structures (Example) | |
| Σ | 0..1 | Reference(Device | DeviceMetric) | Observing Device | |
| ΣI | 0..1 | positiveInt | Height of the image in pixels (photo/video) | |
| ΣI | 0..1 | positiveInt | Width of the image in pixels (photo/video) | |
| ΣI | 0..1 | positiveInt | Number of frames if > 1 (photo) | |
| ΣI | 0..1 | unsignedInt | Length in seconds (audio / video) | |
| 1..1 | Attachment | Actual Media - reference or data | ||
| 0..* | Annotation | Comments made about the media | ||
| Documentation for this format |
\"].value"
},
{
"identity": "dicom",
"map": "0028,0010"
}
]
},
{
"id": "Media.width",
"path": "Media.width",
"short": "Width of the image in pixels (photo/video)",
"definition": "Width of the image in pixels (photo/video).",
"min": 0,
"max": "1",
"type": [
{
"code": "positiveInt"
}
],
"condition": [
"mda-2"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"OBS\", moodCode=\"EVN\",code=\"\"].value"
},
{
"identity": "dicom",
"map": "0028,0011"
}
]
},
{
"id": "Media.frames",
"path": "Media.frames",
"short": "Number of frames if > 1 (photo)",
"definition": "The number of frames in a photo. This is used with a multi-page fax, or an imaging acquisition context that takes multiple slices in a single image, or an animated gif. If there is more than one frame, this SHALL have a value in order to alert interface software that a multi-frame capable rendering widget is required.",
"min": 0,
"max": "1",
"type": [
{
"code": "positiveInt"
}
],
"defaultValuePositiveInt": 1,
"condition": [
"mda-3"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"OBS\", moodCode=\"EVN\",code=\"\"].value"
}
]
},
{
"id": "Media.duration",
"path": "Media.duration",
"short": "Length in seconds (audio / video)",
"definition": "The duration of the recording in seconds - for audio and video.",
"comment": "The duration might differ from occurrencePeriod if recording was paused.",
"min": 0,
"max": "1",
"type": [
{
"code": "unsignedInt"
}
],
"condition": [
"mda-4"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"OBS\", moodCode=\"EVN\",code=\"\"].value"
},
{
"identity": "dicom",
"map": "~0028,0002"
}
]
},
{
"id": "Media.content",
"path": "Media.content",
"short": "Actual Media - reference or data",
"definition": "The actual content of the media - inline or by direct reference to the media source file.",
"comment": "Recommended content types: image/jpeg, image/png, image/tiff, video/mpeg, audio/mp4, application/dicom. Application/dicom can contain the transfer syntax as a parameter. For an media that covers a period of time (video/sound), the content.creationTime is the end time. Creation time is used for tracking, organizing versions and searching.",
"min": 1,
"max": "1",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "Media.note",
"path": "Media.note",
"short": "Comments made about the media",
"definition": "Comments made about the media by the performer, subject or other participants.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "v2",
"map": "NTE"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=ANNGEN, moodCode=EVN].value[xsi:type=ST]"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Media",
"path": "Media",
"short": "A photo, video, or audio recording acquired or used in healthcare. The actual content may be inline or provided by direct reference",
"definition": "A photo, video, or audio recording acquired or used in healthcare. The actual content may be inline or provided by direct reference.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "mda-1",
"severity": "error",
"human": "Height can only be used for a photo or video",
"expression": "height.empty() or type != 'audio'",
"xpath": "not(f:type/@value='audio') or not(f:height)"
},
{
"key": "mda-2",
"severity": "error",
"human": "Width can only be used for a photo or video",
"expression": "width.empty() or type != 'audio'",
"xpath": "not(f:type/@value='audio') or not(f:width)"
},
{
"key": "mda-3",
"severity": "error",
"human": "Frames can only be used for a photo",
"expression": "frames.empty() or type = 'photo'",
"xpath": "(f:type/@value='photo') or not(f:frames)"
},
{
"key": "mda-4",
"severity": "error",
"human": "Duration can only be used for an audio or a video",
"expression": "duration.empty() or type != 'photo'",
"xpath": "not(f:type/@value='photo') or not(f:duration)"
}
],
"mapping": [
{
"identity": "rim",
"map": "Act[classCode=\"DGIMG\", moodCode=\"EVN\"]"
},
{
"identity": "w5",
"map": "infrastructure.structure"
}
]
},
{
"id": "Media.identifier",
"path": "Media.identifier",
"short": "Identifier(s) for the image",
"definition": "Identifiers associated with the image - these may include identifiers for the image itself, identifiers for the context of its collection (e.g. series ids) and context ids such as accession numbers or other workflow identifiers.",
"comment": "The identifier label and use can be used to determine what kind of identifier it is.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".id"
},
{
"identity": "dicom",
"map": "0008,0018 | ~0008,0050 | 0020,000D | 0020,000E"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Media.basedOn",
"path": "Media.basedOn",
"short": "Procedure that caused this media to be created",
"definition": "A procedure that is fulfilled in whole or in part by the creation of this media.",
"requirements": "Allows tracing of authorization for the event and tracking whether proposals/recommendations were acted upon.",
"alias": [
"fulfills"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target"
}
]
},
{
"id": "Media.type",
"path": "Media.type",
"short": "photo | video | audio",
"definition": "Whether the media is a photo (still image), an audio recording, or a video recording.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "DigitalMediaType"
}
],
"strength": "required",
"description": "Whether the media is a photo, video, or audio",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/digital-media-type"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Media.subtype",
"path": "Media.subtype",
"short": "The type of acquisition equipment/process",
"definition": "Details of the type of the media - usually, how it was acquired (what type of device). If images sourced from a DICOM system, are wrapped in a Media resource, then this is the modality.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "DigitalMediaSubtype"
}
],
"strength": "example",
"description": "Detailed information about the type of the image - its kind, purpose, or the kind of equipment used to generate it",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/digital-media-subtype"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"LIST\", moodCode=\"EVN\"].code"
},
{
"identity": "dicom",
"map": "0008,0060 | 0008,1032"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Media.view",
"path": "Media.view",
"short": "Imaging view, e.g. Lateral or Antero-posterior",
"definition": "The name of the imaging view e.g. Lateral or Antero-posterior (AP).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MediaView"
}
],
"strength": "example",
"description": "Imaging view (projection) used when collecting an image",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/media-view"
}
},
"mapping": [
{
"identity": "rim",
"map": "DiagnosticImage.subjectOrientationCode"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Media.subject",
"path": "Media.subject",
"short": "Who/What this Media is a record of",
"definition": "Who/What this Media is a record of.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Specimen"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=\"SUBJ\"]???"
},
{
"identity": "dicom",
"map": "~0010,0020"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Media.context",
"path": "Media.context",
"short": "Encounter / Episode associated with media",
"definition": "The encounter or episode of care that establishes the context for this media.",
"comment": "This will typically be the encounter the media occurred within.",
"requirements": "Links the media to the Encounter context.",
"alias": [
"encounter"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=COMP].source[classCode<=PCPR, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "Media.occurrence[x]",
"path": "Media.occurrence[x]",
"short": "When Media was collected",
"definition": "The date and time(s) at which the media was collected.",
"alias": [
"timing"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Media.operator",
"path": "Media.operator",
"short": "The person who generated the image",
"definition": "The person who administered the collection of the image.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=\"PERF\"]???"
},
{
"identity": "dicom",
"map": "0008,1060?"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Media.reasonCode",
"path": "Media.reasonCode",
"short": "Why was event performed?",
"definition": "Describes why the event occurred in coded or textual form.",
"comment": "Textual reasons can be caprued using reasonCode.text.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MediaReason"
}
],
"strength": "example",
"description": "The reason for the media",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-reason"
}
},
"mapping": [
{
"identity": "rim",
"map": ".reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Media.bodySite",
"path": "Media.bodySite",
"short": "Body part in media",
"definition": "Indicates the site on the subject's body where the media was collected (i.e. the target site).",
"comment": "If the use case requires BodySite to be handled as a separate resource (e.g. to identify and track separately) then use The standard extension[ body-site-instance](extension-body-site-instance.html).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "BodySite"
}
],
"strength": "example",
"description": "Codes describing anatomical locations. May include laterality.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/body-site"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 123037004 |Body structure|"
},
{
"identity": "rim",
"map": "targetSiteCode"
},
{
"identity": "sct-attr",
"map": "718497002 |Inherent location|"
}
]
},
{
"id": "Media.device",
"path": "Media.device",
"short": "Observing Device",
"definition": "The device used to collect the media.",
"comment": "An extension should be used if further typing of the device is needed. Scondary devices used to support collecting a media can be represented using either extension or through the Observation.related element.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DeviceMetric"
}
],
"isSummary": true,
"mapping": [
{
"identity": "sct-concept",
"map": "< 49062001 |Device|"
},
{
"identity": "rim",
"map": "participation[typeCode=DEV]"
},
{
"identity": "sct-attr",
"map": "424226004 |Using device|"
}
]
},
{
"id": "Media.height",
"path": "Media.height",
"short": "Height of the image in pixels (photo/video)",
"definition": "Height of the image in pixels (photo/video).",
"min": 0,
"max": "1",
"type": [
{
"code": "positiveInt"
}
],
"condition": [
"mda-1"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"OBS\", moodCode=\"EVN\",code=\"\"].value"
},
{
"identity": "dicom",
"map": "0028,0010"
}
]
},
{
"id": "Media.width",
"path": "Media.width",
"short": "Width of the image in pixels (photo/video)",
"definition": "Width of the image in pixels (photo/video).",
"min": 0,
"max": "1",
"type": [
{
"code": "positiveInt"
}
],
"condition": [
"mda-2"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"OBS\", moodCode=\"EVN\",code=\"\"].value"
},
{
"identity": "dicom",
"map": "0028,0011"
}
]
},
{
"id": "Media.frames",
"path": "Media.frames",
"short": "Number of frames if > 1 (photo)",
"definition": "The number of frames in a photo. This is used with a multi-page fax, or an imaging acquisition context that takes multiple slices in a single image, or an animated gif. If there is more than one frame, this SHALL have a value in order to alert interface software that a multi-frame capable rendering widget is required.",
"min": 0,
"max": "1",
"type": [
{
"code": "positiveInt"
}
],
"defaultValuePositiveInt": 1,
"condition": [
"mda-3"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"OBS\", moodCode=\"EVN\",code=\"\"].value"
}
]
},
{
"id": "Media.duration",
"path": "Media.duration",
"short": "Length in seconds (audio / video)",
"definition": "The duration of the recording in seconds - for audio and video.",
"comment": "The duration might differ from occurrencePeriod if recording was paused.",
"min": 0,
"max": "1",
"type": [
{
"code": "unsignedInt"
}
],
"condition": [
"mda-4"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"OBS\", moodCode=\"EVN\",code=\"\"].value"
},
{
"identity": "dicom",
"map": "~0028,0002"
}
]
},
{
"id": "Media.content",
"path": "Media.content",
"short": "Actual Media - reference or data",
"definition": "The actual content of the media - inline or by direct reference to the media source file.",
"comment": "Recommended content types: image/jpeg, image/png, image/tiff, video/mpeg, audio/mp4, application/dicom. Application/dicom can contain the transfer syntax as a parameter. For an media that covers a period of time (video/sound), the content.creationTime is the end time. Creation time is used for tracking, organizing versions and searching.",
"min": 1,
"max": "1",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "Media.note",
"path": "Media.note",
"short": "Comments made about the media",
"definition": "Comments made about the media by the performer, subject or other participants.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "v2",
"map": "NTE"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=ANNGEN, moodCode=EVN].value[xsi:type=ST]"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Medication",
"resource": {
"resourceType": "StructureDefinition",
"id": "Medication",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints ![\".\"](\"data:)
Medication DomainResource Definition of a Medication
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension code Σ 0..1 CodeableConcept Codes that identify this medication
SNOMED CT Medication Codes (Example) status Σ 0..1 code active | inactive | entered-in-error
MedicationStatus (Required) isBrand Σ 0..1 boolean True if a brand isOverTheCounter Σ 0..1 boolean True if medication does not require a prescription manufacturer Σ 0..1 Reference(Organization) Manufacturer of the item form 0..1 CodeableConcept powder | tablets | capsule +
SNOMED CT Form Codes (Example) ingredient 0..* BackboneElement Active or inactive ingredient
item[x] 1..1 The product contained itemCodeableConcept CodeableConcept itemReference Reference(Substance | Medication) isActive 0..1 boolean Active ingredient indicator amount 0..1 Ratio Quantity of ingredient present package 0..1 BackboneElement Details about packaged medications container 0..1 CodeableConcept E.g. box, vial, blister-pack
MedicationContainer (Example) content 0..* BackboneElement What is in the package
item[x] 1..1 The item in the package itemCodeableConcept CodeableConcept itemReference Reference(Medication) amount 0..1 SimpleQuantity Quantity present in the package batch 0..* BackboneElement Identifies a single production run
lotNumber 0..1 string Identifier assigned to batch expirationDate 0..1 dateTime When batch will expire image 0..* Attachment Picture of the medication
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "phx"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Medication",
"name": "Medication",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Pharmacy)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/medication/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Medication Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "script10.6",
"uri": "http://ncpdp.org/SCRIPT10_6",
"name": "Mapping to NCPDP SCRIPT 10.6"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Medication",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Medication",
"path": "Medication",
"short": "Definition of a Medication",
"definition": "This resource is primarily used for the identification and definition of a medication. It covers the ingredients and the packaging for a medication.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "script10.6",
"map": "NewRx/MedicationPrescribed\r-or-\rRxFill/MedicationDispensed\r-or-\rRxHistoryResponse/MedicationDispensed\r-or-\rRxHistoryResponse/MedicationPrescribed"
},
{
"identity": "rim",
"map": "ManufacturedProduct[classCode=ADMM]"
},
{
"identity": "w5",
"map": "clinical.medication"
}
]
},
{
"id": "Medication.id",
"path": "Medication.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Medication.meta",
"path": "Medication.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Medication.implicitRules",
"path": "Medication.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Medication.language",
"path": "Medication.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Medication.text",
"path": "Medication.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Medication.contained",
"path": "Medication.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Medication.extension",
"path": "Medication.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Medication.modifierExtension",
"path": "Medication.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Medication.code",
"path": "Medication.code",
"short": "Codes that identify this medication",
"definition": "A code (or set of codes) that specify this medication, or a textual description if no code is available. Usage note: This could be a standard medication code such as a code from RxNorm, SNOMED CT, IDMP etc. It could also be a national or local formulary code, optionally with translations to other code systems.",
"comment": "Depending on the context of use, the code that was actually selected by the user (prescriber, dispenser, etc.) will have the coding.userSelected set to true. As described in the coding datatype: \"A coding may be marked as a \"userSelected\" if a user selected the particular coded value in a user interface (e.g. the user selects an item in a pick-list). If a user selected coding exists, it is the preferred choice for performing translations etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationFormalRepresentation"
}
],
"strength": "example",
"description": "A coded concept that defines the type of a medication",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-codes"
}
},
"mapping": [
{
"identity": "script10.6",
"map": "coding.code = //element(*,MedicationType)/DrugCoded/ProductCode\r\rcoding.system = //element(*,MedicationType)/DrugCoded/ProductCodeQualifier\r\rcoding.display = //element(*,MedicationType)/DrugDescription"
},
{
"identity": "v2",
"map": "RXO-1.1-Requested Give Code.code / RXE-2.1-Give Code.code / RXD-2.1-Dispense/Give Code.code / RXG-4.1-Give Code.code /RXA-5.1-Administered Code.code / RXC-2.1 Component Code"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Medication.status",
"path": "Medication.status",
"short": "active | inactive | entered-in-error",
"definition": "A code to indicate if the medication is in active use.",
"comment": "This status is not intended to specify if a medication is part of a formulary.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationStatus"
}
],
"strength": "required",
"description": "A coded concept defining if the medication is in active use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".statusCode"
}
]
},
{
"id": "Medication.isBrand",
"path": "Medication.isBrand",
"short": "True if a brand",
"definition": "Set to true if the item is attributable to a specific manufacturer.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true,
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": "true if .player.scopingRole[typeCode=MANU] exists"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Medication.isOverTheCounter",
"path": "Medication.isOverTheCounter",
"short": "True if medication does not require a prescription",
"definition": "Set to true if the medication can be obtained without an order from a prescriber.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "NA"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Medication.manufacturer",
"path": "Medication.manufacturer",
"short": "Manufacturer of the item",
"definition": "Describes the details of the manufacturer of the medication product. This is not intended to represent the distributor of a medication product.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "v2",
"map": "RXD-20-Substance Manufacturer Name / RXG-21-Substance Manufacturer Name / RXA-17-Substance Manufacturer Name"
},
{
"identity": "rim",
"map": ".player.scopingRole[typeCode=MANU].scoper"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Medication.form",
"path": "Medication.form",
"short": "powder | tablets | capsule +",
"definition": "Describes the form of the item. Powder; tablets; capsule.",
"comment": "When Medication is referenced from MedicationRequest, this is the ordered form. When Medication is referenced within MedicationDispense, this is the dispensed form. When Medication is referenced within MedicationAdministration, this is administered form.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationForm"
}
],
"strength": "example",
"description": "A coded concept defining the form of a medication",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-form-codes"
}
},
"mapping": [
{
"identity": "script10.6",
"map": "coding.code = //element(*,DrugCodedType)/FormCode\r\rcoding.system = //element(*,DrugCodedType)/FormSourceCode"
},
{
"identity": "v2",
"map": "RXO-5-Requested Dosage Form / RXE-6-Give Dosage Form / RXD-6-Actual Dosage Form / RXG-8-Give Dosage Form / RXA-8-Administered Dosage Form"
},
{
"identity": "rim",
"map": ".formCode"
}
]
},
{
"id": "Medication.ingredient",
"path": "Medication.ingredient",
"short": "Active or inactive ingredient",
"definition": "Identifies a particular constituent of interest in the product.",
"comment": "The ingredients need not be a complete list. If an ingredient is not specified, this does not indicate whether an ingredient is present or absent. If an ingredient is specified it does not mean that all ingredients are specified. It is possible to specify both inactive and active ingredients.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".scopesRole[typeCode=INGR]"
}
]
},
{
"id": "Medication.ingredient.id",
"path": "Medication.ingredient.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Medication.ingredient.extension",
"path": "Medication.ingredient.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Medication.ingredient.modifierExtension",
"path": "Medication.ingredient.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Medication.ingredient.item[x]",
"path": "Medication.ingredient.item[x]",
"short": "The product contained",
"definition": "The actual ingredient - either a substance (simple ingredient) or another medication.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "coding.code = //element(*,MedicationType)/DrugCoded/ProductCode\r\rcoding.system = //element(*,MedicationType)/DrugCoded/ProductCodeQualifier\r\rcoding.display = //element(*,MedicationType)/DrugDescription"
},
{
"identity": "v2",
"map": "RXC-2-Component Code if medication: RXO-1-Requested Give Code / RXE-2-Give Code / RXD-2-Dispense/Give Code / RXG-4-Give Code / RXA-5-Administered Code"
},
{
"identity": "rim",
"map": ".player"
}
]
},
{
"id": "Medication.ingredient.isActive",
"path": "Medication.ingredient.isActive",
"short": "Active ingredient indicator",
"definition": "Indication of whether this ingredient affects the therapeutic action of the drug.",
"requirements": "True indicates that the ingredient affects the therapeutic action of the drug (i.e. active). \rFalse indicates that the ingredient does not affect the therapeutic action of the drug (i.e. inactive).",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"mapping": [
{
"identity": "rim",
"map": "NA"
}
]
},
{
"id": "Medication.ingredient.amount",
"path": "Medication.ingredient.amount",
"short": "Quantity of ingredient present",
"definition": "Specifies how many (or how much) of the items there are in this Medication. For example, 250 mg per tablet. This is expressed as a ratio where the numerator is 250mg and the denominator is 1 tablet.",
"min": 0,
"max": "1",
"type": [
{
"code": "Ratio"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "//element(*,DrugCodedType)/Strength"
},
{
"identity": "v2",
"map": "RXC-3-Component Amount & RXC-4-Component Units if medication: RXO-2-Requested Give Amount - Minimum & RXO-4-Requested Give Units / RXO-3-Requested Give Amount - Maximum & RXO-4-Requested Give Units / RXO-11-Requested Dispense Amount & RXO-12-Requested Dispense Units / RXE-3-Give Amount - Minimum & RXE-5-Give Units / RXE-4-Give Amount - Maximum & RXE-5-Give Units / RXE-10-Dispense Amount & RXE-10-Dispense Units"
},
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "Medication.package",
"path": "Medication.package",
"short": "Details about packaged medications",
"definition": "Information that only applies to packages (not products).",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".player[classCode=CONT]"
}
]
},
{
"id": "Medication.package.id",
"path": "Medication.package.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Medication.package.extension",
"path": "Medication.package.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Medication.package.modifierExtension",
"path": "Medication.package.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Medication.package.container",
"path": "Medication.package.container",
"short": "E.g. box, vial, blister-pack",
"definition": "The kind of container that this package comes as.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationContainer"
}
],
"strength": "example",
"description": "A coded concept defining the kind of container a medication package is packaged in",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-package-form"
}
},
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "Medication.package.content",
"path": "Medication.package.content",
"short": "What is in the package",
"definition": "A set of components that go to make up the described item.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".scopesRole[typeCode=CONT]"
}
]
},
{
"id": "Medication.package.content.id",
"path": "Medication.package.content.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Medication.package.content.extension",
"path": "Medication.package.content.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Medication.package.content.modifierExtension",
"path": "Medication.package.content.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Medication.package.content.item[x]",
"path": "Medication.package.content.item[x]",
"short": "The item in the package",
"definition": "Identifies one of the items in the package.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".player"
}
]
},
{
"id": "Medication.package.content.amount",
"path": "Medication.package.content.amount",
"short": "Quantity present in the package",
"definition": "The amount of the product that is in the package.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "Medication.package.batch",
"path": "Medication.package.batch",
"short": "Identifies a single production run",
"definition": "Information about a group of medication produced or packaged from one production run.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": "participation[typeCode=CSM].role[classCode=INST].scopedRole.scoper[classCode=MMAT].id"
}
]
},
{
"id": "Medication.package.batch.id",
"path": "Medication.package.batch.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Medication.package.batch.extension",
"path": "Medication.package.batch.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Medication.package.batch.modifierExtension",
"path": "Medication.package.batch.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Medication.package.batch.lotNumber",
"path": "Medication.package.batch.lotNumber",
"short": "Identifier assigned to batch",
"definition": "The assigned lot number of a batch of the specified product.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "v2",
"map": "RXA-15 Substance Lot Number / RXG-19 Substance Lot Number"
},
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "Medication.package.batch.expirationDate",
"path": "Medication.package.batch.expirationDate",
"short": "When batch will expire",
"definition": "When this specific batch of product will expire.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "v2",
"map": "RXA-16 Substance Expiration Date / RXG-20 Substance Expiration Date"
},
{
"identity": "rim",
"map": "participation[typeCode=CSM].role[classCode=INST].scopedRole.scoper[classCode=MMAT].expirationTime"
}
]
},
{
"id": "Medication.image",
"path": "Medication.image",
"short": "Picture of the medication",
"definition": "Photo(s) or graphic representation(s) of the medication.",
"requirements": "Note that \"image\" is only applicable when the medication.code represents a physical item (e.g. Amoxil 250 mg capsule) and not an abstract item (e.g. amoxicillin 250 mg).",
"min": 0,
"max": "*",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=SUBJ].role[classCode=MANU],source[classCode=OBS,moodCode=EVN,code=\"type of image\"].value(ED.image)"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Medication",
"path": "Medication",
"short": "Definition of a Medication",
"definition": "This resource is primarily used for the identification and definition of a medication. It covers the ingredients and the packaging for a medication.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "script10.6",
"map": "NewRx/MedicationPrescribed\r-or-\rRxFill/MedicationDispensed\r-or-\rRxHistoryResponse/MedicationDispensed\r-or-\rRxHistoryResponse/MedicationPrescribed"
},
{
"identity": "rim",
"map": "ManufacturedProduct[classCode=ADMM]"
},
{
"identity": "w5",
"map": "clinical.medication"
}
]
},
{
"id": "Medication.code",
"path": "Medication.code",
"short": "Codes that identify this medication",
"definition": "A code (or set of codes) that specify this medication, or a textual description if no code is available. Usage note: This could be a standard medication code such as a code from RxNorm, SNOMED CT, IDMP etc. It could also be a national or local formulary code, optionally with translations to other code systems.",
"comment": "Depending on the context of use, the code that was actually selected by the user (prescriber, dispenser, etc.) will have the coding.userSelected set to true. As described in the coding datatype: \"A coding may be marked as a \"userSelected\" if a user selected the particular coded value in a user interface (e.g. the user selects an item in a pick-list). If a user selected coding exists, it is the preferred choice for performing translations etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationFormalRepresentation"
}
],
"strength": "example",
"description": "A coded concept that defines the type of a medication",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-codes"
}
},
"mapping": [
{
"identity": "script10.6",
"map": "coding.code = //element(*,MedicationType)/DrugCoded/ProductCode\r\rcoding.system = //element(*,MedicationType)/DrugCoded/ProductCodeQualifier\r\rcoding.display = //element(*,MedicationType)/DrugDescription"
},
{
"identity": "v2",
"map": "RXO-1.1-Requested Give Code.code / RXE-2.1-Give Code.code / RXD-2.1-Dispense/Give Code.code / RXG-4.1-Give Code.code /RXA-5.1-Administered Code.code / RXC-2.1 Component Code"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Medication.status",
"path": "Medication.status",
"short": "active | inactive | entered-in-error",
"definition": "A code to indicate if the medication is in active use.",
"comment": "This status is not intended to specify if a medication is part of a formulary.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationStatus"
}
],
"strength": "required",
"description": "A coded concept defining if the medication is in active use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".statusCode"
}
]
},
{
"id": "Medication.isBrand",
"path": "Medication.isBrand",
"short": "True if a brand",
"definition": "Set to true if the item is attributable to a specific manufacturer.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true,
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": "true if .player.scopingRole[typeCode=MANU] exists"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Medication.isOverTheCounter",
"path": "Medication.isOverTheCounter",
"short": "True if medication does not require a prescription",
"definition": "Set to true if the medication can be obtained without an order from a prescriber.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "NA"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Medication.manufacturer",
"path": "Medication.manufacturer",
"short": "Manufacturer of the item",
"definition": "Describes the details of the manufacturer of the medication product. This is not intended to represent the distributor of a medication product.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "v2",
"map": "RXD-20-Substance Manufacturer Name / RXG-21-Substance Manufacturer Name / RXA-17-Substance Manufacturer Name"
},
{
"identity": "rim",
"map": ".player.scopingRole[typeCode=MANU].scoper"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Medication.form",
"path": "Medication.form",
"short": "powder | tablets | capsule +",
"definition": "Describes the form of the item. Powder; tablets; capsule.",
"comment": "When Medication is referenced from MedicationRequest, this is the ordered form. When Medication is referenced within MedicationDispense, this is the dispensed form. When Medication is referenced within MedicationAdministration, this is administered form.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationForm"
}
],
"strength": "example",
"description": "A coded concept defining the form of a medication",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-form-codes"
}
},
"mapping": [
{
"identity": "script10.6",
"map": "coding.code = //element(*,DrugCodedType)/FormCode\r\rcoding.system = //element(*,DrugCodedType)/FormSourceCode"
},
{
"identity": "v2",
"map": "RXO-5-Requested Dosage Form / RXE-6-Give Dosage Form / RXD-6-Actual Dosage Form / RXG-8-Give Dosage Form / RXA-8-Administered Dosage Form"
},
{
"identity": "rim",
"map": ".formCode"
}
]
},
{
"id": "Medication.ingredient",
"path": "Medication.ingredient",
"short": "Active or inactive ingredient",
"definition": "Identifies a particular constituent of interest in the product.",
"comment": "The ingredients need not be a complete list. If an ingredient is not specified, this does not indicate whether an ingredient is present or absent. If an ingredient is specified it does not mean that all ingredients are specified. It is possible to specify both inactive and active ingredients.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".scopesRole[typeCode=INGR]"
}
]
},
{
"id": "Medication.ingredient.item[x]",
"path": "Medication.ingredient.item[x]",
"short": "The product contained",
"definition": "The actual ingredient - either a substance (simple ingredient) or another medication.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "coding.code = //element(*,MedicationType)/DrugCoded/ProductCode\r\rcoding.system = //element(*,MedicationType)/DrugCoded/ProductCodeQualifier\r\rcoding.display = //element(*,MedicationType)/DrugDescription"
},
{
"identity": "v2",
"map": "RXC-2-Component Code if medication: RXO-1-Requested Give Code / RXE-2-Give Code / RXD-2-Dispense/Give Code / RXG-4-Give Code / RXA-5-Administered Code"
},
{
"identity": "rim",
"map": ".player"
}
]
},
{
"id": "Medication.ingredient.isActive",
"path": "Medication.ingredient.isActive",
"short": "Active ingredient indicator",
"definition": "Indication of whether this ingredient affects the therapeutic action of the drug.",
"requirements": "True indicates that the ingredient affects the therapeutic action of the drug (i.e. active). \rFalse indicates that the ingredient does not affect the therapeutic action of the drug (i.e. inactive).",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"mapping": [
{
"identity": "rim",
"map": "NA"
}
]
},
{
"id": "Medication.ingredient.amount",
"path": "Medication.ingredient.amount",
"short": "Quantity of ingredient present",
"definition": "Specifies how many (or how much) of the items there are in this Medication. For example, 250 mg per tablet. This is expressed as a ratio where the numerator is 250mg and the denominator is 1 tablet.",
"min": 0,
"max": "1",
"type": [
{
"code": "Ratio"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "//element(*,DrugCodedType)/Strength"
},
{
"identity": "v2",
"map": "RXC-3-Component Amount & RXC-4-Component Units if medication: RXO-2-Requested Give Amount - Minimum & RXO-4-Requested Give Units / RXO-3-Requested Give Amount - Maximum & RXO-4-Requested Give Units / RXO-11-Requested Dispense Amount & RXO-12-Requested Dispense Units / RXE-3-Give Amount - Minimum & RXE-5-Give Units / RXE-4-Give Amount - Maximum & RXE-5-Give Units / RXE-10-Dispense Amount & RXE-10-Dispense Units"
},
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "Medication.package",
"path": "Medication.package",
"short": "Details about packaged medications",
"definition": "Information that only applies to packages (not products).",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".player[classCode=CONT]"
}
]
},
{
"id": "Medication.package.container",
"path": "Medication.package.container",
"short": "E.g. box, vial, blister-pack",
"definition": "The kind of container that this package comes as.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationContainer"
}
],
"strength": "example",
"description": "A coded concept defining the kind of container a medication package is packaged in",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-package-form"
}
},
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "Medication.package.content",
"path": "Medication.package.content",
"short": "What is in the package",
"definition": "A set of components that go to make up the described item.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".scopesRole[typeCode=CONT]"
}
]
},
{
"id": "Medication.package.content.item[x]",
"path": "Medication.package.content.item[x]",
"short": "The item in the package",
"definition": "Identifies one of the items in the package.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".player"
}
]
},
{
"id": "Medication.package.content.amount",
"path": "Medication.package.content.amount",
"short": "Quantity present in the package",
"definition": "The amount of the product that is in the package.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "Medication.package.batch",
"path": "Medication.package.batch",
"short": "Identifies a single production run",
"definition": "Information about a group of medication produced or packaged from one production run.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": "participation[typeCode=CSM].role[classCode=INST].scopedRole.scoper[classCode=MMAT].id"
}
]
},
{
"id": "Medication.package.batch.lotNumber",
"path": "Medication.package.batch.lotNumber",
"short": "Identifier assigned to batch",
"definition": "The assigned lot number of a batch of the specified product.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "v2",
"map": "RXA-15 Substance Lot Number / RXG-19 Substance Lot Number"
},
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "Medication.package.batch.expirationDate",
"path": "Medication.package.batch.expirationDate",
"short": "When batch will expire",
"definition": "When this specific batch of product will expire.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "v2",
"map": "RXA-16 Substance Expiration Date / RXG-20 Substance Expiration Date"
},
{
"identity": "rim",
"map": "participation[typeCode=CSM].role[classCode=INST].scopedRole.scoper[classCode=MMAT].expirationTime"
}
]
},
{
"id": "Medication.image",
"path": "Medication.image",
"short": "Picture of the medication",
"definition": "Photo(s) or graphic representation(s) of the medication.",
"requirements": "Note that \"image\" is only applicable when the medication.code represents a physical item (e.g. Amoxil 250 mg capsule) and not an abstract item (e.g. amoxicillin 250 mg).",
"min": 0,
"max": "*",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=SUBJ].role[classCode=MANU],source[classCode=OBS,moodCode=EVN,code=\"type of image\"].value(ED.image)"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/MedicationAdministration",
"resource": {
"resourceType": "StructureDefinition",
"id": "MedicationAdministration",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints MedicationAdministration I DomainResource Administration of medication to a patient
+ Reason not given is only permitted if NotGiven is true
+ Reason given is only permitted if NotGiven is false
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..* Identifier External identifier
definition Σ 0..* Reference(PlanDefinition | ActivityDefinition) Instantiates protocol or definition
partOf Σ 0..* Reference(MedicationAdministration | Procedure) Part of referenced event
status ?!Σ 1..1 code in-progress | on-hold | completed | entered-in-error | stopped | unknown
MedicationAdministrationStatus (Required) category 0..1 CodeableConcept Type of medication usage
MedicationAdministrationCategory (Preferred) medication[x] Σ 1..1 What was administered
SNOMED CT Medication Codes (Example) medicationCodeableConcept CodeableConcept medicationReference Reference(Medication) subject Σ 1..1 Reference(Patient | Group) Who received medication context 0..1 Reference(Encounter | EpisodeOfCare) Encounter or Episode of Care administered as part of supportingInformation 0..* Reference(Any) Additional information to support administration
effective[x] Σ 1..1 Start and end time of administration effectiveDateTime dateTime effectivePeriod Period performer Σ 0..* BackboneElement Who administered substance
actor Σ 1..1 Reference(Practitioner | Patient | RelatedPerson | Device) Individual who was performing onBehalfOf 0..1 Reference(Organization) Organization organization was acting for notGiven ?!Σ 0..1 boolean True if medication not administered reasonNotGiven I 0..* CodeableConcept Reason administration not performed
SNOMED CT Reason Medication Not Given Codes (Example)
reasonCode I 0..* CodeableConcept Reason administration performed
Reason Medication Given Codes (Example)
reasonReference 0..* Reference(Condition | Observation) Condition or Observation that supports why the medication was administered
prescription 0..1 Reference(MedicationRequest) Request administration performed against device 0..* Reference(Device) Device used to administer
note 0..* Annotation Information about the administration
dosage I 0..1 BackboneElement Details of how medication was taken
+ SHALL have at least one of dosage.dose or dosage.rate[x] text 0..1 string Free text dosage instructions e.g. SIG site 0..1 CodeableConcept Body site administered to
SNOMED CT Anatomical Structure for Administration Site Codes (Example) route 0..1 CodeableConcept Path of substance into body
SNOMED CT Route Codes (Example) method 0..1 CodeableConcept How drug was administered
SNOMED CT Administration Method Codes (Example) dose 0..1 SimpleQuantity Amount of medication per dose rate[x] 0..1 Dose quantity per unit of time rateRatio Ratio rateQuantity SimpleQuantity eventHistory 0..* Reference(Provenance) A list of events of interest in the lifecycle
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "phx"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/MedicationAdministration",
"name": "MedicationAdministration",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Pharmacy)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/medication/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for MedicationAdministration Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "w3c.prov",
"uri": "http://www.w3.org/ns/prov",
"name": "W3C PROV"
}
],
"kind": "resource",
"abstract": false,
"type": "MedicationAdministration",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "MedicationAdministration",
"path": "MedicationAdministration",
"short": "Administration of medication to a patient",
"definition": "Describes the event of a patient consuming or otherwise being administered a medication. This may be as simple as swallowing a tablet or it may be a long running infusion. Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner.",
"comment": "The WG will be updating the MedicationAdministration resource to adjust each affected resource to align with the workflow pattern (see workflow.html).",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "mad-2",
"severity": "error",
"human": "Reason not given is only permitted if NotGiven is true",
"expression": "reasonNotGiven.empty() or notGiven = true",
"xpath": "not(exists(f:reasonNotGiven) and f:notGiven/@value=false())"
},
{
"key": "mad-3",
"severity": "error",
"human": "Reason given is only permitted if NotGiven is false",
"expression": "reasonCode.empty() or notGiven.empty() or notGiven = 'false'",
"xpath": "not(exists(f:reasonCode) and f:notGiven/@value=true())"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "..Event"
},
{
"identity": "rim",
"map": "SubstanceAdministration"
},
{
"identity": "w5",
"map": "clinical.medication"
}
]
},
{
"id": "MedicationAdministration.id",
"path": "MedicationAdministration.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "MedicationAdministration.meta",
"path": "MedicationAdministration.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "MedicationAdministration.implicitRules",
"path": "MedicationAdministration.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "MedicationAdministration.language",
"path": "MedicationAdministration.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "MedicationAdministration.text",
"path": "MedicationAdministration.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "MedicationAdministration.contained",
"path": "MedicationAdministration.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationAdministration.extension",
"path": "MedicationAdministration.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationAdministration.modifierExtension",
"path": "MedicationAdministration.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationAdministration.identifier",
"path": "MedicationAdministration.identifier",
"short": "External identifier",
"definition": "External identifier - FHIR will generate its own internal identifiers (probably URLs) which do not need to be explicitly managed by the resource. The identifier here is one that would be used by another non-FHIR system - for example an automated medication pump would provide a record each time it operated; an administration while the patient was off the ward might be made with a different system and entered after the event. Particularly important if these records have to be updated.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…identifier"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MedicationAdministration.definition",
"path": "MedicationAdministration.definition",
"short": "Instantiates protocol or definition",
"definition": "A protocol, guideline, orderset or other definition that was adhered to in whole or in part by this event.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…definition"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target[classCode=unspecified]"
}
]
},
{
"id": "MedicationAdministration.partOf",
"path": "MedicationAdministration.partOf",
"short": "Part of referenced event",
"definition": "A larger event of which this particular event is a component or step.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationAdministration"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Procedure"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…part of"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP]/target[classCode=SBADM or PROC,moodCode=EVN]"
}
]
},
{
"id": "MedicationAdministration.status",
"path": "MedicationAdministration.status",
"short": "in-progress | on-hold | completed | entered-in-error | stopped | unknown",
"definition": "Will generally be set to show that the administration has been completed. For some long running administrations such as infusions it is possible for an administration to be started but not completed or it may be paused while some other process is under way.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationStatus"
}
],
"strength": "required",
"description": "A set of codes indicating the current status of a MedicationAdministration.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-admin-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…status"
},
{
"identity": "v2",
"map": "RXA-20-Completion Status"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MedicationAdministration.category",
"path": "MedicationAdministration.category",
"short": "Type of medication usage",
"definition": "Indicates the type of medication administration and where the medication is expected to be consumed or administered.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationCategory"
}
],
"strength": "preferred",
"description": "A coded concept describing where the medication administered is expected to occur",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-admin-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=OBS, moodCode=EVN, code=\"type of medication usage\"].value"
}
]
},
{
"id": "MedicationAdministration.medication[x]",
"path": "MedicationAdministration.medication[x]",
"short": "What was administered",
"definition": "Identifies the medication that was administered. This is either a link to a resource representing the details of the medication or a simple attribute carrying a code that identifies the medication from a known list of medications.",
"comment": "If only a code is specified, then it needs to be a code for a specific product. If more information is required, then the use of the medication resource is recommended. For example if you require form or lot number, then you must reference the Medication resource. .",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationCode"
}
],
"strength": "example",
"description": "Codes identifying substance or product that can be administered.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…code"
},
{
"identity": "v2",
"map": "RXA-5-Administered Code"
},
{
"identity": "rim",
"map": ".participation[typeCode=CSM].role[classCode=ADMM]"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "MedicationAdministration.subject",
"path": "MedicationAdministration.subject",
"short": "Who received medication",
"definition": "The person or animal or group receiving the medication.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…subject"
},
{
"identity": "v2",
"map": "PID-3-Patient ID List"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role[classCode=PAT]"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MedicationAdministration.context",
"path": "MedicationAdministration.context",
"short": "Encounter or Episode of Care administered as part of",
"definition": "The visit, admission or other contact between patient and health care provider the medication administration was performed as part of.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…context"
},
{
"identity": "v2",
"map": "PV1-19-Visit Number"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN, code=\"type of encounter or episode\"]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "MedicationAdministration.supportingInformation",
"path": "MedicationAdministration.supportingInformation",
"short": "Additional information to support administration",
"definition": "Additional information (for example, patient height and weight) that supports the administration of the medication.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=PERT].target[A_SupportingClinicalStatement CMET minimal with many different choices of classCodes(ORG, ENC, PROC, SPLY, SBADM, OBS) and each of the act class codes draws from one or more of the following moodCodes (EVN, DEF, INT PRMS, RQO, PRP, APT, ARQ, GOL)]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "MedicationAdministration.effective[x]",
"path": "MedicationAdministration.effective[x]",
"short": "Start and end time of administration",
"definition": "A specific date/time or interval of time during which the administration took place (or did not take place, when the 'notGiven' attribute is true). For many administrations, such as swallowing a tablet the use of dateTime is more appropriate.",
"min": 1,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…occurrence[x]"
},
{
"identity": "v2",
"map": "RXA-3-Date/Time Start of Administration / RXA-4-Date/Time End of Administration"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "MedicationAdministration.performer",
"path": "MedicationAdministration.performer",
"short": "Who administered substance",
"definition": "The individual who was responsible for giving the medication to the patient.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…performer"
},
{
"identity": "v2",
"map": "RXA-10-Administering Provider / PRT-5-Participation Person: PRT-4-Participation='AP' (RXA-10 is deprecated)"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF]"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "MedicationAdministration.performer.id",
"path": "MedicationAdministration.performer.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationAdministration.performer.extension",
"path": "MedicationAdministration.performer.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationAdministration.performer.modifierExtension",
"path": "MedicationAdministration.performer.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationAdministration.performer.actor",
"path": "MedicationAdministration.performer.actor",
"short": "Individual who was performing",
"definition": "The device, practitioner, etc. who performed the action.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "….actor"
},
{
"identity": "rim",
"map": ".role"
}
]
},
{
"id": "MedicationAdministration.performer.onBehalfOf",
"path": "MedicationAdministration.performer.onBehalfOf",
"short": "Organization organization was acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "….onBehalfOf"
},
{
"identity": "rim",
"map": ".role.scopingOrganization"
}
]
},
{
"id": "MedicationAdministration.notGiven",
"path": "MedicationAdministration.notGiven",
"short": "True if medication not administered",
"definition": "Set this to true if the record is saying that the medication was NOT administered.",
"comment": "This element is labeled as a modifier because it indicates that a administration didn't happen.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"meaningWhenMissing": "If this is missing, then the medication was administered",
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…notDone"
},
{
"identity": "v2",
"map": "RXA-20-Completion Status='NA'"
},
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "MedicationAdministration.reasonNotGiven",
"path": "MedicationAdministration.reasonNotGiven",
"short": "Reason administration not performed",
"definition": "A code indicating why the administration was not performed.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"mad-2"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationNegationReason"
}
],
"strength": "example",
"description": "A set of codes indicating the reason why the MedicationAdministration is negated.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/reason-medication-not-given-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…notDoneReason"
},
{
"identity": "v2",
"map": "RXA-9-Administration Notes / RXA-18 Substance/Treatment Refusal Reason"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON]/target[classCode=OBS,moodCode=EVN, code=\"reason not given\"].value"
}
]
},
{
"id": "MedicationAdministration.reasonCode",
"path": "MedicationAdministration.reasonCode",
"short": "Reason administration performed",
"definition": "A code indicating why the medication was given.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"mad-3"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationReason"
}
],
"strength": "example",
"description": "A set of codes indicating the reason why the MedicationAdministration was made.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/reason-medication-given-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…reasonGivenCodeableConcept"
},
{
"identity": "v2",
"map": "RXE-27 Give Indication"
},
{
"identity": "rim",
"map": ".reasonCode"
}
]
},
{
"id": "MedicationAdministration.reasonReference",
"path": "MedicationAdministration.reasonReference",
"short": "Condition or Observation that supports why the medication was administered",
"definition": "Condition or observation that supports why the medication was administered.",
"comment": "This is a reference to a condition that is the reason for the medication request. If only a code exists, use reasonCode.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…reasonReference"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON]/target[classCode=OBS,moodCode=EVN, code=\"reason for use ASSERTION\"].value"
},
{
"identity": "w3c.prov",
"map": "no mapping"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MedicationAdministration.prescription",
"path": "MedicationAdministration.prescription",
"short": "Request administration performed against",
"definition": "The original request, instruction or authority to perform the administration.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…basedOn"
},
{
"identity": "v2",
"map": "ORC-2-Placer Order Number / ORC-3-Filler Order Number"
},
{
"identity": "rim",
"map": "InFullfillmentOf->SubstanceAdministration"
}
]
},
{
"id": "MedicationAdministration.device",
"path": "MedicationAdministration.device",
"short": "Device used to administer",
"definition": "The device used in administering the medication to the patient. For example, a particular infusion pump.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"mapping": [
{
"identity": "v2",
"map": "PRT-10 Participation Device / RXR-3 Administrative Device"
},
{
"identity": "rim",
"map": "device->Access OR device->AssignedDevice"
}
]
},
{
"id": "MedicationAdministration.note",
"path": "MedicationAdministration.note",
"short": "Information about the administration",
"definition": "Extra information about the medication administration that is not conveyed by the other attributes.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…note"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=OBS,moodCode=EVN,code=\"annotation\"].value"
}
]
},
{
"id": "MedicationAdministration.dosage",
"path": "MedicationAdministration.dosage",
"short": "Details of how medication was taken",
"definition": "Describes the medication dosage information details e.g. dose, rate, site, route, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "mad-1",
"severity": "error",
"human": "SHALL have at least one of dosage.dose or dosage.rate[x]",
"expression": "dose.exists() or rate.exists()",
"xpath": "exists(f:dose) or exists(f:*[starts-with(local-name(.), 'rate')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "component->SubstanceAdministrationEvent"
}
]
},
{
"id": "MedicationAdministration.dosage.id",
"path": "MedicationAdministration.dosage.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationAdministration.dosage.extension",
"path": "MedicationAdministration.dosage.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationAdministration.dosage.modifierExtension",
"path": "MedicationAdministration.dosage.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationAdministration.dosage.text",
"path": "MedicationAdministration.dosage.text",
"short": "Free text dosage instructions e.g. SIG",
"definition": "Free text dosage can be used for cases where the dosage administered is too complex to code. When coded dosage is present, the free text dosage may still be present for display to humans.\r\rThe dosage instructions should reflect the dosage of the medication that was administered.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "MedicationAdministration.dosage.site",
"path": "MedicationAdministration.dosage.site",
"short": "Body site administered to",
"definition": "A coded specification of the anatomic site where the medication first entered the body. For example, \"left arm\".",
"comment": "If the use case requires attributes from the BodySite resource (e.g. to identify and track separately) then use the standard extension [body-site-instance](extension-body-site-instance.html). May be a summary code, or a reference to a very precise definition of the location, or both.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationSite"
}
],
"strength": "example",
"description": "A coded concept describing the site location the medicine enters into or onto the body.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/approach-site-codes"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXR-2 Administration Site / RXR-6 Administration Site Modifier"
},
{
"identity": "rim",
"map": ".approachSiteCode"
}
]
},
{
"id": "MedicationAdministration.dosage.route",
"path": "MedicationAdministration.dosage.route",
"short": "Path of substance into body",
"definition": "A code specifying the route or physiological path of administration of a therapeutic agent into or onto the patient. For example, topical, intravenous, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RouteOfAdministration"
}
],
"strength": "example",
"description": "A coded concept describing the route or physiological path of administration of a therapeutic agent into or onto the body of a subject.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/route-codes"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXR-1-Route"
},
{
"identity": "rim",
"map": ".routeCode"
}
]
},
{
"id": "MedicationAdministration.dosage.method",
"path": "MedicationAdministration.dosage.method",
"short": "How drug was administered",
"definition": "A coded value indicating the method by which the medication is intended to be or was introduced into or on the body. This attribute will most often NOT be populated. It is most commonly used for injections. For example, Slow Push, Deep IV.",
"comment": "One of the reasons this attribute is not used often, is that the method is often pre-coordinated with the route and/or form of administration. This means the codes used in route or form may pre-coordinate the method in the route code or the form code. The implementation decision about what coding system to use for route or form code will determine how frequently the method code will be populated e.g. if route or form code pre-coordinate method code, then this attribute will not be populated often; if there is no pre-coordination then method code may be used frequently.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationMethod"
}
],
"strength": "example",
"description": "A coded concept describing the technique by which the medicine is administered.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administration-method-codes"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXR-4-Administration Method"
},
{
"identity": "rim",
"map": ".methodCode"
}
]
},
{
"id": "MedicationAdministration.dosage.dose",
"path": "MedicationAdministration.dosage.dose",
"short": "Amount of medication per dose",
"definition": "The amount of the medication given at one administration event. Use this value when the administration is essentially an instantaneous event such as a swallowing a tablet or giving an injection.",
"comment": "If the administration is not instantaneous (rate is present), this can be specified to convey the total amount administered over period of time of a single administration.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "RXA-6 Administered Amount / RXA-7 Administered Units"
},
{
"identity": "rim",
"map": ".doseQuantity"
}
]
},
{
"id": "MedicationAdministration.dosage.rate[x]",
"path": "MedicationAdministration.dosage.rate[x]",
"short": "Dose quantity per unit of time",
"definition": "Identifies the speed with which the medication was or will be introduced into the patient. Typically the rate for an infusion e.g. 100 ml per 1 hour or 100 ml/hr. May also be expressed as a rate per unit of time e.g. 500 ml per 2 hours. Other examples: 200 mcg/min or 200 mcg/1 minute; 1 liter/8 hours.",
"comment": "If the rate changes over time, and you want to capture this in MedicationAdministration, then each change should be captured as a distinct MedicationAdministration, with a specific MedicationAdministration.dosage.rate, and the date time when the rate change occurred. Typically, the MedicationAdministration.dosage.rate element is not used to convey an average rate.",
"min": 0,
"max": "1",
"type": [
{
"code": "Ratio"
},
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "RXA-12-Administered Per (Time Unit)"
},
{
"identity": "rim",
"map": ".rateQuantity"
}
]
},
{
"id": "MedicationAdministration.eventHistory",
"path": "MedicationAdministration.eventHistory",
"short": "A list of events of interest in the lifecycle",
"definition": "A summary of the events of interest that have occurred, such as when the administration was verified.",
"comment": "This may not include provenances for all versions of the request – only those deemed “relevant” or important. This SHALL NOT include the Provenance associated with this current version of the resource. (If that provenance is deemed to be a “relevant” change, it will need to be added as part of a later update. Until then, it can be queried directly as the Provenance that points to this version using _revinclude All Provenances should have some historical version of this Request as their subject.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
}
]
},
"differential": {
"element": [
{
"id": "MedicationAdministration",
"path": "MedicationAdministration",
"short": "Administration of medication to a patient",
"definition": "Describes the event of a patient consuming or otherwise being administered a medication. This may be as simple as swallowing a tablet or it may be a long running infusion. Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner.",
"comment": "The WG will be updating the MedicationAdministration resource to adjust each affected resource to align with the workflow pattern (see workflow.html).",
"min": 0,
"max": "*",
"constraint": [
{
"key": "mad-2",
"severity": "error",
"human": "Reason not given is only permitted if NotGiven is true",
"expression": "reasonNotGiven.empty() or notGiven = true",
"xpath": "not(exists(f:reasonNotGiven) and f:notGiven/@value=false())"
},
{
"key": "mad-3",
"severity": "error",
"human": "Reason given is only permitted if NotGiven is false",
"expression": "reasonCode.empty() or notGiven.empty() or notGiven = 'false'",
"xpath": "not(exists(f:reasonCode) and f:notGiven/@value=true())"
}
],
"mapping": [
{
"identity": "workflow",
"map": "..Event"
},
{
"identity": "rim",
"map": "SubstanceAdministration"
},
{
"identity": "w5",
"map": "clinical.medication"
}
]
},
{
"id": "MedicationAdministration.identifier",
"path": "MedicationAdministration.identifier",
"short": "External identifier",
"definition": "External identifier - FHIR will generate its own internal identifiers (probably URLs) which do not need to be explicitly managed by the resource. The identifier here is one that would be used by another non-FHIR system - for example an automated medication pump would provide a record each time it operated; an administration while the patient was off the ward might be made with a different system and entered after the event. Particularly important if these records have to be updated.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…identifier"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MedicationAdministration.definition",
"path": "MedicationAdministration.definition",
"short": "Instantiates protocol or definition",
"definition": "A protocol, guideline, orderset or other definition that was adhered to in whole or in part by this event.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…definition"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target[classCode=unspecified]"
}
]
},
{
"id": "MedicationAdministration.partOf",
"path": "MedicationAdministration.partOf",
"short": "Part of referenced event",
"definition": "A larger event of which this particular event is a component or step.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationAdministration"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Procedure"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…part of"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP]/target[classCode=SBADM or PROC,moodCode=EVN]"
}
]
},
{
"id": "MedicationAdministration.status",
"path": "MedicationAdministration.status",
"short": "in-progress | on-hold | completed | entered-in-error | stopped | unknown",
"definition": "Will generally be set to show that the administration has been completed. For some long running administrations such as infusions it is possible for an administration to be started but not completed or it may be paused while some other process is under way.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationStatus"
}
],
"strength": "required",
"description": "A set of codes indicating the current status of a MedicationAdministration.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-admin-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…status"
},
{
"identity": "v2",
"map": "RXA-20-Completion Status"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MedicationAdministration.category",
"path": "MedicationAdministration.category",
"short": "Type of medication usage",
"definition": "Indicates the type of medication administration and where the medication is expected to be consumed or administered.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationCategory"
}
],
"strength": "preferred",
"description": "A coded concept describing where the medication administered is expected to occur",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-admin-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=OBS, moodCode=EVN, code=\"type of medication usage\"].value"
}
]
},
{
"id": "MedicationAdministration.medication[x]",
"path": "MedicationAdministration.medication[x]",
"short": "What was administered",
"definition": "Identifies the medication that was administered. This is either a link to a resource representing the details of the medication or a simple attribute carrying a code that identifies the medication from a known list of medications.",
"comment": "If only a code is specified, then it needs to be a code for a specific product. If more information is required, then the use of the medication resource is recommended. For example if you require form or lot number, then you must reference the Medication resource. .",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationCode"
}
],
"strength": "example",
"description": "Codes identifying substance or product that can be administered.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…code"
},
{
"identity": "v2",
"map": "RXA-5-Administered Code"
},
{
"identity": "rim",
"map": ".participation[typeCode=CSM].role[classCode=ADMM]"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "MedicationAdministration.subject",
"path": "MedicationAdministration.subject",
"short": "Who received medication",
"definition": "The person or animal or group receiving the medication.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…subject"
},
{
"identity": "v2",
"map": "PID-3-Patient ID List"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role[classCode=PAT]"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MedicationAdministration.context",
"path": "MedicationAdministration.context",
"short": "Encounter or Episode of Care administered as part of",
"definition": "The visit, admission or other contact between patient and health care provider the medication administration was performed as part of.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…context"
},
{
"identity": "v2",
"map": "PV1-19-Visit Number"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN, code=\"type of encounter or episode\"]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "MedicationAdministration.supportingInformation",
"path": "MedicationAdministration.supportingInformation",
"short": "Additional information to support administration",
"definition": "Additional information (for example, patient height and weight) that supports the administration of the medication.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=PERT].target[A_SupportingClinicalStatement CMET minimal with many different choices of classCodes(ORG, ENC, PROC, SPLY, SBADM, OBS) and each of the act class codes draws from one or more of the following moodCodes (EVN, DEF, INT PRMS, RQO, PRP, APT, ARQ, GOL)]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "MedicationAdministration.effective[x]",
"path": "MedicationAdministration.effective[x]",
"short": "Start and end time of administration",
"definition": "A specific date/time or interval of time during which the administration took place (or did not take place, when the 'notGiven' attribute is true). For many administrations, such as swallowing a tablet the use of dateTime is more appropriate.",
"min": 1,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…occurrence[x]"
},
{
"identity": "v2",
"map": "RXA-3-Date/Time Start of Administration / RXA-4-Date/Time End of Administration"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "MedicationAdministration.performer",
"path": "MedicationAdministration.performer",
"short": "Who administered substance",
"definition": "The individual who was responsible for giving the medication to the patient.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…performer"
},
{
"identity": "v2",
"map": "RXA-10-Administering Provider / PRT-5-Participation Person: PRT-4-Participation='AP' (RXA-10 is deprecated)"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF]"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "MedicationAdministration.performer.actor",
"path": "MedicationAdministration.performer.actor",
"short": "Individual who was performing",
"definition": "The device, practitioner, etc. who performed the action.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "….actor"
},
{
"identity": "rim",
"map": ".role"
}
]
},
{
"id": "MedicationAdministration.performer.onBehalfOf",
"path": "MedicationAdministration.performer.onBehalfOf",
"short": "Organization organization was acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "….onBehalfOf"
},
{
"identity": "rim",
"map": ".role.scopingOrganization"
}
]
},
{
"id": "MedicationAdministration.notGiven",
"path": "MedicationAdministration.notGiven",
"short": "True if medication not administered",
"definition": "Set this to true if the record is saying that the medication was NOT administered.",
"comment": "This element is labeled as a modifier because it indicates that a administration didn't happen.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"meaningWhenMissing": "If this is missing, then the medication was administered",
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…notDone"
},
{
"identity": "v2",
"map": "RXA-20-Completion Status='NA'"
},
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "MedicationAdministration.reasonNotGiven",
"path": "MedicationAdministration.reasonNotGiven",
"short": "Reason administration not performed",
"definition": "A code indicating why the administration was not performed.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"mad-2"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationNegationReason"
}
],
"strength": "example",
"description": "A set of codes indicating the reason why the MedicationAdministration is negated.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/reason-medication-not-given-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…notDoneReason"
},
{
"identity": "v2",
"map": "RXA-9-Administration Notes / RXA-18 Substance/Treatment Refusal Reason"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON]/target[classCode=OBS,moodCode=EVN, code=\"reason not given\"].value"
}
]
},
{
"id": "MedicationAdministration.reasonCode",
"path": "MedicationAdministration.reasonCode",
"short": "Reason administration performed",
"definition": "A code indicating why the medication was given.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"mad-3"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationReason"
}
],
"strength": "example",
"description": "A set of codes indicating the reason why the MedicationAdministration was made.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/reason-medication-given-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…reasonGivenCodeableConcept"
},
{
"identity": "v2",
"map": "RXE-27 Give Indication"
},
{
"identity": "rim",
"map": ".reasonCode"
}
]
},
{
"id": "MedicationAdministration.reasonReference",
"path": "MedicationAdministration.reasonReference",
"short": "Condition or Observation that supports why the medication was administered",
"definition": "Condition or observation that supports why the medication was administered.",
"comment": "This is a reference to a condition that is the reason for the medication request. If only a code exists, use reasonCode.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…reasonReference"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON]/target[classCode=OBS,moodCode=EVN, code=\"reason for use ASSERTION\"].value"
},
{
"identity": "w3c.prov",
"map": "no mapping"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MedicationAdministration.prescription",
"path": "MedicationAdministration.prescription",
"short": "Request administration performed against",
"definition": "The original request, instruction or authority to perform the administration.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…basedOn"
},
{
"identity": "v2",
"map": "ORC-2-Placer Order Number / ORC-3-Filler Order Number"
},
{
"identity": "rim",
"map": "InFullfillmentOf->SubstanceAdministration"
}
]
},
{
"id": "MedicationAdministration.device",
"path": "MedicationAdministration.device",
"short": "Device used to administer",
"definition": "The device used in administering the medication to the patient. For example, a particular infusion pump.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"mapping": [
{
"identity": "v2",
"map": "PRT-10 Participation Device / RXR-3 Administrative Device"
},
{
"identity": "rim",
"map": "device->Access OR device->AssignedDevice"
}
]
},
{
"id": "MedicationAdministration.note",
"path": "MedicationAdministration.note",
"short": "Information about the administration",
"definition": "Extra information about the medication administration that is not conveyed by the other attributes.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…note"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=OBS,moodCode=EVN,code=\"annotation\"].value"
}
]
},
{
"id": "MedicationAdministration.dosage",
"path": "MedicationAdministration.dosage",
"short": "Details of how medication was taken",
"definition": "Describes the medication dosage information details e.g. dose, rate, site, route, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "mad-1",
"severity": "error",
"human": "SHALL have at least one of dosage.dose or dosage.rate[x]",
"expression": "dose.exists() or rate.exists()",
"xpath": "exists(f:dose) or exists(f:*[starts-with(local-name(.), 'rate')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "component->SubstanceAdministrationEvent"
}
]
},
{
"id": "MedicationAdministration.dosage.text",
"path": "MedicationAdministration.dosage.text",
"short": "Free text dosage instructions e.g. SIG",
"definition": "Free text dosage can be used for cases where the dosage administered is too complex to code. When coded dosage is present, the free text dosage may still be present for display to humans.\r\rThe dosage instructions should reflect the dosage of the medication that was administered.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "MedicationAdministration.dosage.site",
"path": "MedicationAdministration.dosage.site",
"short": "Body site administered to",
"definition": "A coded specification of the anatomic site where the medication first entered the body. For example, \"left arm\".",
"comment": "If the use case requires attributes from the BodySite resource (e.g. to identify and track separately) then use the standard extension [body-site-instance](extension-body-site-instance.html). May be a summary code, or a reference to a very precise definition of the location, or both.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationSite"
}
],
"strength": "example",
"description": "A coded concept describing the site location the medicine enters into or onto the body.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/approach-site-codes"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXR-2 Administration Site / RXR-6 Administration Site Modifier"
},
{
"identity": "rim",
"map": ".approachSiteCode"
}
]
},
{
"id": "MedicationAdministration.dosage.route",
"path": "MedicationAdministration.dosage.route",
"short": "Path of substance into body",
"definition": "A code specifying the route or physiological path of administration of a therapeutic agent into or onto the patient. For example, topical, intravenous, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RouteOfAdministration"
}
],
"strength": "example",
"description": "A coded concept describing the route or physiological path of administration of a therapeutic agent into or onto the body of a subject.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/route-codes"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXR-1-Route"
},
{
"identity": "rim",
"map": ".routeCode"
}
]
},
{
"id": "MedicationAdministration.dosage.method",
"path": "MedicationAdministration.dosage.method",
"short": "How drug was administered",
"definition": "A coded value indicating the method by which the medication is intended to be or was introduced into or on the body. This attribute will most often NOT be populated. It is most commonly used for injections. For example, Slow Push, Deep IV.",
"comment": "One of the reasons this attribute is not used often, is that the method is often pre-coordinated with the route and/or form of administration. This means the codes used in route or form may pre-coordinate the method in the route code or the form code. The implementation decision about what coding system to use for route or form code will determine how frequently the method code will be populated e.g. if route or form code pre-coordinate method code, then this attribute will not be populated often; if there is no pre-coordination then method code may be used frequently.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationAdministrationMethod"
}
],
"strength": "example",
"description": "A coded concept describing the technique by which the medicine is administered.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administration-method-codes"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXR-4-Administration Method"
},
{
"identity": "rim",
"map": ".methodCode"
}
]
},
{
"id": "MedicationAdministration.dosage.dose",
"path": "MedicationAdministration.dosage.dose",
"short": "Amount of medication per dose",
"definition": "The amount of the medication given at one administration event. Use this value when the administration is essentially an instantaneous event such as a swallowing a tablet or giving an injection.",
"comment": "If the administration is not instantaneous (rate is present), this can be specified to convey the total amount administered over period of time of a single administration.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "RXA-6 Administered Amount / RXA-7 Administered Units"
},
{
"identity": "rim",
"map": ".doseQuantity"
}
]
},
{
"id": "MedicationAdministration.dosage.rate[x]",
"path": "MedicationAdministration.dosage.rate[x]",
"short": "Dose quantity per unit of time",
"definition": "Identifies the speed with which the medication was or will be introduced into the patient. Typically the rate for an infusion e.g. 100 ml per 1 hour or 100 ml/hr. May also be expressed as a rate per unit of time e.g. 500 ml per 2 hours. Other examples: 200 mcg/min or 200 mcg/1 minute; 1 liter/8 hours.",
"comment": "If the rate changes over time, and you want to capture this in MedicationAdministration, then each change should be captured as a distinct MedicationAdministration, with a specific MedicationAdministration.dosage.rate, and the date time when the rate change occurred. Typically, the MedicationAdministration.dosage.rate element is not used to convey an average rate.",
"min": 0,
"max": "1",
"type": [
{
"code": "Ratio"
},
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "RXA-12-Administered Per (Time Unit)"
},
{
"identity": "rim",
"map": ".rateQuantity"
}
]
},
{
"id": "MedicationAdministration.eventHistory",
"path": "MedicationAdministration.eventHistory",
"short": "A list of events of interest in the lifecycle",
"definition": "A summary of the events of interest that have occurred, such as when the administration was verified.",
"comment": "This may not include provenances for all versions of the request – only those deemed “relevant” or important. This SHALL NOT include the Provenance associated with this current version of the resource. (If that provenance is deemed to be a “relevant” change, it will need to be added as part of a later update. Until then, it can be queried directly as the Provenance that points to this version using _revinclude All Provenances should have some historical version of this Request as their subject.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/MedicationDispense",
"resource": {
"resourceType": "StructureDefinition",
"id": "MedicationDispense",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints MedicationDispense I DomainResource Dispensing a medication to a named patient
+ whenHandedOver cannot be before whenPrepared
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..* Identifier External identifier
partOf 0..* Reference(Procedure) Event that dispense is part of
status ?!Σ 0..1 code preparation | in-progress | on-hold | completed | entered-in-error | stopped
MedicationDispenseStatus (Required) category 0..1 CodeableConcept Type of medication dispense
MedicationDispenseCategory (Preferred) medication[x] Σ 1..1 What medication was supplied
SNOMED CT Medication Codes (Example) medicationCodeableConcept CodeableConcept medicationReference Reference(Medication) subject Σ 0..1 Reference(Patient | Group) Who the dispense is for context 0..1 Reference(Encounter | EpisodeOfCare) Encounter / Episode associated with event supportingInformation 0..* Reference(Any) Information that supports the dispensing of the medication
performer 0..* BackboneElement Who performed event
actor 1..1 Reference(Practitioner | Organization | Patient | Device | RelatedPerson) Individual who was performing onBehalfOf 0..1 Reference(Organization) Organization organization was acting for authorizingPrescription 0..* Reference(MedicationRequest) Medication order that authorizes the dispense
type 0..1 CodeableConcept Trial fill, partial fill, emergency fill, etc.
ActPharmacySupplyType (Example) quantity 0..1 SimpleQuantity Amount dispensed daysSupply 0..1 SimpleQuantity Amount of medication expressed as a timing amount whenPrepared Σ 0..1 dateTime When product was packaged and reviewed whenHandedOver 0..1 dateTime When product was given out destination 0..1 Reference(Location) Where the medication was sent receiver 0..* Reference(Patient | Practitioner) Who collected the medication
note 0..* Annotation Information about the dispense
dosageInstruction 0..* Dosage How the medication is to be used by the patient or administered by the caregiver
substitution 0..1 BackboneElement Whether a substitution was performed on the dispense wasSubstituted 1..1 boolean Whether a substitution was or was not performed on the dispense type 0..1 CodeableConcept Code signifying whether a different drug was dispensed from what was prescribed
ActSubstanceAdminSubstitutionCode (Example) reason 0..* CodeableConcept Why was substitution made
SubstanceAdminSubstitutionReason (Example)
responsibleParty 0..* Reference(Practitioner) Who is responsible for the substitution
detectedIssue 0..* Reference(DetectedIssue) Clinical issue with action
notDone 0..1 boolean Whether the dispense was or was not performed notDoneReason[x] 0..1 Why a dispense was not performed notDoneReasonCodeableConcept CodeableConcept notDoneReasonReference Reference(DetectedIssue) eventHistory 0..* Reference(Provenance) A list of releveant lifecycle events
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "phx"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/MedicationDispense",
"name": "MedicationDispense",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Pharmacy)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/medication/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for MedicationDispense Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "MedicationDispense",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "MedicationDispense",
"path": "MedicationDispense",
"short": "Dispensing a medication to a named patient",
"definition": "Indicates that a medication product is to be or has been dispensed for a named person/patient. This includes a description of the medication product (supply) provided and the instructions for administering the medication. The medication dispense is the result of a pharmacy system responding to a medication order.",
"comment": "The WG will be updating the MedicationDispense resource to adjust each affected resource to align with the workflow pattern (see workflow.html).",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "mdd-1",
"severity": "error",
"human": "whenHandedOver cannot be before whenPrepared",
"expression": "whenHandedOver.empty() or whenPrepared.empty() or whenHandedOver >= whenPrepared",
"xpath": "not(exists(f:whenHandedOver/@value)) or not(exists(f:whenPrepared/@value)) or ( f:whenHandedOver/@value >= f:whenPrepared/@value)"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "..Event"
},
{
"identity": "rim",
"map": "Supply[moodCode=EVN]"
},
{
"identity": "w5",
"map": "clinical.medication"
}
]
},
{
"id": "MedicationDispense.id",
"path": "MedicationDispense.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "MedicationDispense.meta",
"path": "MedicationDispense.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "MedicationDispense.implicitRules",
"path": "MedicationDispense.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "MedicationDispense.language",
"path": "MedicationDispense.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "MedicationDispense.text",
"path": "MedicationDispense.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "MedicationDispense.contained",
"path": "MedicationDispense.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationDispense.extension",
"path": "MedicationDispense.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationDispense.modifierExtension",
"path": "MedicationDispense.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationDispense.identifier",
"path": "MedicationDispense.identifier",
"short": "External identifier",
"definition": "Identifier assigned by the dispensing facility - this is an identifier assigned outside FHIR.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…identifier"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MedicationDispense.partOf",
"path": "MedicationDispense.partOf",
"short": "Event that dispense is part of",
"definition": "The procedure that the dispense is done because of.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Procedure"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…part of"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP]/target[classCode=PROC,moodCode=EVN]"
}
]
},
{
"id": "MedicationDispense.status",
"path": "MedicationDispense.status",
"short": "preparation | in-progress | on-hold | completed | entered-in-error | stopped",
"definition": "A code specifying the state of the set of dispense events.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationDispenseStatus"
}
],
"strength": "required",
"description": "A coded concept specifying the state of the dispense event.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-dispense-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…status"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MedicationDispense.category",
"path": "MedicationDispense.category",
"short": "Type of medication dispense",
"definition": "Indicates type of medication dispense and where the medication is expected to be consumed or administered.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationDispenseCategory"
}
],
"strength": "preferred",
"description": "A code describing where the dispensed medication is expected to be consumed or administered",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-dispense-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=OBS, moodCode=EVN, code=\"type of medication dispense\"].value"
}
]
},
{
"id": "MedicationDispense.medication[x]",
"path": "MedicationDispense.medication[x]",
"short": "What medication was supplied",
"definition": "Identifies the medication being administered. This is either a link to a resource representing the details of the medication or a simple attribute carrying a code that identifies the medication from a known list of medications.",
"comment": "If only a code is specified, then it needs to be a code for a specific product. If more information is required, then the use of the medication resource is recommended. For example if you require form or lot number, then you must reference the Medication resource. .",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationCode"
}
],
"strength": "example",
"description": "A coded concept identifying which substance or product can be dispensed",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…code"
},
{
"identity": "v2",
"map": "RXD-2-Dispense/Give Code"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRD].role"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "MedicationDispense.subject",
"path": "MedicationDispense.subject",
"short": "Who the dispense is for",
"definition": "A link to a resource representing the person or the group to whom the medication will be given.",
"comment": "SubstanceAdministration->subject->Patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…subject"
},
{
"identity": "v2",
"map": "PID-3-Patient ID List"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role[classCode=PAT]"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MedicationDispense.context",
"path": "MedicationDispense.context",
"short": "Encounter / Episode associated with event",
"definition": "The encounter or episode of care that establishes the context for this event.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…context"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN, code=\"type of encounter or episode\"]"
}
]
},
{
"id": "MedicationDispense.supportingInformation",
"path": "MedicationDispense.supportingInformation",
"short": "Information that supports the dispensing of the medication",
"definition": "Additional information that supports the medication being dispensed.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=PERT].target[A_SupportingClinicalStatement CMET minimal with many different choices of classCodes(ORG, ENC, PROC, SPLY, SBADM, OBS) and each of the act class codes draws from one or more of the following moodCodes (EVN, DEF, INT PRMS, RQO, PRP, APT, ARQ, GOL)]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "MedicationDispense.performer",
"path": "MedicationDispense.performer",
"short": "Who performed event",
"definition": "Indicates who or what performed the event. It should be assumed that the performer is the dispenser of the medication.",
"comment": "The performer will be reviewed as part of STU4.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…performer"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF]"
}
]
},
{
"id": "MedicationDispense.performer.id",
"path": "MedicationDispense.performer.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationDispense.performer.extension",
"path": "MedicationDispense.performer.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationDispense.performer.modifierExtension",
"path": "MedicationDispense.performer.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationDispense.performer.actor",
"path": "MedicationDispense.performer.actor",
"short": "Individual who was performing",
"definition": "The device, practitioner, etc. who performed the action. It should be assumed that the actor is the dispenser of the medication.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"mapping": [
{
"identity": "workflow",
"map": "….actor"
},
{
"identity": "rim",
"map": ".role"
}
]
},
{
"id": "MedicationDispense.performer.onBehalfOf",
"path": "MedicationDispense.performer.onBehalfOf",
"short": "Organization organization was acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "….onBehalfOf"
},
{
"identity": "rim",
"map": ".role.scopingOrganization"
}
]
},
{
"id": "MedicationDispense.authorizingPrescription",
"path": "MedicationDispense.authorizingPrescription",
"short": "Medication order that authorizes the dispense",
"definition": "Indicates the medication order that is being dispensed against.",
"comment": "Maps to basedOn in Event logical model.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…basedOn"
},
{
"identity": "v2",
"map": "ORC-2 Placer Order Number"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target[moodCode=RQO]"
}
]
},
{
"id": "MedicationDispense.type",
"path": "MedicationDispense.type",
"short": "Trial fill, partial fill, emergency fill, etc.",
"definition": "Indicates the type of dispensing event that is performed. For example, Trial Fill, Completion of Trial, Partial Fill, Emergency Fill, Samples, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationDispenseType"
}
],
"strength": "example",
"description": "Indicates the type of dispensing event that is performed. For example, Trial Fill, Completion of Trial, Partial Fill, Emergency Fill, Samples, etc.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-ActPharmacySupplyType"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXD-33-Dispense Type"
},
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "MedicationDispense.quantity",
"path": "MedicationDispense.quantity",
"short": "Amount dispensed",
"definition": "The amount of medication that has been dispensed. Includes unit of measure.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "RXD-4-Actual Dispense Amount / RXD-5.1-Actual Dispense Units.code / RXD-5.3-Actual Dispense Units.name of coding system"
},
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "MedicationDispense.daysSupply",
"path": "MedicationDispense.daysSupply",
"short": "Amount of medication expressed as a timing amount",
"definition": "The amount of medication expressed as a timing amount.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "TQ1.6 Timing/Quantity Segment Service Duration.\rPrior to v2.5, ORC.7.3 Common Order Segment / Quantity/Timing / Duration component. This is a formatted string, first character for the time unit (e.g., D=days), followed by the value. For example, “D14” represents “14 days supply”\rFrom v2.5 on, TQ1.6 Timing/Quantity Segment / Service Duration. This is a CQ data type ( ^ ), thus for days supply, assuming the unit of measure is “days”, the numeric value is TQ1.6.1 (…|14^\rFor backwards compatibility, ORC.7 was permitted through v2.6. Both forms (field and segment) may be present in v2.5, v2.5.1, and v2.6"
},
{
"identity": "rim",
"map": "effectiveUseTime"
}
]
},
{
"id": "MedicationDispense.whenPrepared",
"path": "MedicationDispense.whenPrepared",
"short": "When product was packaged and reviewed",
"definition": "The time when the dispensed product was packaged and reviewed.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "RXD-3-Date/Time Dispensed"
},
{
"identity": "rim",
"map": ".effectiveTime[xmi:type=IVL_TS].low"
}
]
},
{
"id": "MedicationDispense.whenHandedOver",
"path": "MedicationDispense.whenHandedOver",
"short": "When product was given out",
"definition": "The time the dispensed product was provided to the patient or their representative.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…occurrenceDateTime"
},
{
"identity": "v2",
"map": "RXD-3-Date/Time Dispensed"
},
{
"identity": "rim",
"map": ".effectiveTime[xmi:type=IVL_TS].high"
}
]
},
{
"id": "MedicationDispense.destination",
"path": "MedicationDispense.destination",
"short": "Where the medication was sent",
"definition": "Identification of the facility/location where the medication was shipped to, as part of the dispense event.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"mapping": [
{
"identity": "v2",
"map": "RXD-13 Dispense-to Location; RXD-30 Dispense to Pharmacy; RXD-31 Dispense to Pharmacy Address"
},
{
"identity": "rim",
"map": ".participation[typeCode=DST].role"
}
]
},
{
"id": "MedicationDispense.receiver",
"path": "MedicationDispense.receiver",
"short": "Who collected the medication",
"definition": "Identifies the person who picked up the medication. This will usually be a patient or their caregiver, but some cases exist where it can be a healthcare professional.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=RCV].role"
}
]
},
{
"id": "MedicationDispense.note",
"path": "MedicationDispense.note",
"short": "Information about the dispense",
"definition": "Extra information about the dispense that could not be conveyed in the other attributes.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…note"
},
{
"identity": "v2",
"map": "RXD-9 Dispense Notes"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=ACT,moodCode=EVN]"
}
]
},
{
"id": "MedicationDispense.dosageInstruction",
"path": "MedicationDispense.dosageInstruction",
"short": "How the medication is to be used by the patient or administered by the caregiver",
"definition": "Indicates how the medication is to be used by the patient.",
"comment": "When the dose or rate is intended to change over the entire administration period (e.g. Tapering dose prescriptions), multiple instances of dosage instructions will need to be supplied to convey the different doses/rates.\rThe pharmacist reviews the medication order prior to dispense and updates the dosageInstruction based on the actual product being dispensed.",
"min": 0,
"max": "*",
"type": [
{
"code": "Dosage"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=SBADM, moodCode=INT]"
}
]
},
{
"id": "MedicationDispense.substitution",
"path": "MedicationDispense.substitution",
"short": "Whether a substitution was performed on the dispense",
"definition": "Indicates whether or not substitution was made as part of the dispense. In some cases substitution will be expected but does not happen, in other cases substitution is not expected but does happen. This block explains what substitution did or did not happen and why. If nothing is specified, substitution was not done.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=SUBST, moodCode=EVN]"
}
]
},
{
"id": "MedicationDispense.substitution.id",
"path": "MedicationDispense.substitution.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationDispense.substitution.extension",
"path": "MedicationDispense.substitution.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationDispense.substitution.modifierExtension",
"path": "MedicationDispense.substitution.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationDispense.substitution.wasSubstituted",
"path": "MedicationDispense.substitution.wasSubstituted",
"short": "Whether a substitution was or was not performed on the dispense",
"definition": "True if the dispenser dispensed a different drug or product from what was prescribed.",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"mapping": [
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "MedicationDispense.substitution.type",
"path": "MedicationDispense.substitution.type",
"short": "Code signifying whether a different drug was dispensed from what was prescribed",
"definition": "A code signifying whether a different drug was dispensed from what was prescribed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationIntendedSubstitutionType"
}
],
"strength": "example",
"description": "A coded concept describing whether a different medicinal product may be dispensed other than the product as specified exactly in the prescription",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-ActSubstanceAdminSubstitutionCode"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXO-9-Allow Substitutions / RXE-9-Substitution Status"
},
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "MedicationDispense.substitution.reason",
"path": "MedicationDispense.substitution.reason",
"short": "Why was substitution made",
"definition": "Indicates the reason for the substitution of (or lack of substitution) from what was prescribed.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationIntendedSubstitutionReason"
}
],
"strength": "example",
"description": "A coded concept describing the reason that a different medication should (or should not) be substituted from what was prescribed",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-SubstanceAdminSubstitutionReason"
}
},
"mapping": [
{
"identity": "rim",
"map": ".reasonCode"
}
]
},
{
"id": "MedicationDispense.substitution.responsibleParty",
"path": "MedicationDispense.substitution.responsibleParty",
"short": "Who is responsible for the substitution",
"definition": "The person or organization that has primary responsibility for the substitution.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=PFM].role[classCode=ASSIGN]"
}
]
},
{
"id": "MedicationDispense.detectedIssue",
"path": "MedicationDispense.detectedIssue",
"short": "Clinical issue with action",
"definition": "Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, duplicate therapy, dosage alert etc.",
"alias": [
"Contraindication",
"Drug Utilization Review (DUR)",
"Alert"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DetectedIssue"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=ALRT,moodCode=EVN].value"
}
]
},
{
"id": "MedicationDispense.notDone",
"path": "MedicationDispense.notDone",
"short": "Whether the dispense was or was not performed",
"definition": "True if the dispense was not performed for some reason.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…notDone"
},
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "MedicationDispense.notDoneReason[x]",
"path": "MedicationDispense.notDoneReason[x]",
"short": "Why a dispense was not performed",
"definition": "Indicates the reason why a dispense was not performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DetectedIssue"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…notDoneReason"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON]/target[classCode=OBS,moodCode=EVN, code=\"not done reason\"].value"
}
]
},
{
"id": "MedicationDispense.eventHistory",
"path": "MedicationDispense.eventHistory",
"short": "A list of releveant lifecycle events",
"definition": "A summary of the events of interest that have occurred, such as when the dispense was verified.",
"comment": "This may not include provenances for all versions of the request – only those deemed “relevant” or important. This SHALL NOT include the Provenance associated with this current version of the resource. (If that provenance is deemed to be a “relevant” change, it will need to be added as part of a later update. Until then, it can be queried directly as the Provenance that points to this version using _revinclude All Provenances should have some historical version of this Request as their subject.).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
}
]
},
"differential": {
"element": [
{
"id": "MedicationDispense",
"path": "MedicationDispense",
"short": "Dispensing a medication to a named patient",
"definition": "Indicates that a medication product is to be or has been dispensed for a named person/patient. This includes a description of the medication product (supply) provided and the instructions for administering the medication. The medication dispense is the result of a pharmacy system responding to a medication order.",
"comment": "The WG will be updating the MedicationDispense resource to adjust each affected resource to align with the workflow pattern (see workflow.html).",
"min": 0,
"max": "*",
"constraint": [
{
"key": "mdd-1",
"severity": "error",
"human": "whenHandedOver cannot be before whenPrepared",
"expression": "whenHandedOver.empty() or whenPrepared.empty() or whenHandedOver >= whenPrepared",
"xpath": "not(exists(f:whenHandedOver/@value)) or not(exists(f:whenPrepared/@value)) or ( f:whenHandedOver/@value >= f:whenPrepared/@value)"
}
],
"mapping": [
{
"identity": "workflow",
"map": "..Event"
},
{
"identity": "rim",
"map": "Supply[moodCode=EVN]"
},
{
"identity": "w5",
"map": "clinical.medication"
}
]
},
{
"id": "MedicationDispense.identifier",
"path": "MedicationDispense.identifier",
"short": "External identifier",
"definition": "Identifier assigned by the dispensing facility - this is an identifier assigned outside FHIR.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…identifier"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MedicationDispense.partOf",
"path": "MedicationDispense.partOf",
"short": "Event that dispense is part of",
"definition": "The procedure that the dispense is done because of.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Procedure"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…part of"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP]/target[classCode=PROC,moodCode=EVN]"
}
]
},
{
"id": "MedicationDispense.status",
"path": "MedicationDispense.status",
"short": "preparation | in-progress | on-hold | completed | entered-in-error | stopped",
"definition": "A code specifying the state of the set of dispense events.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationDispenseStatus"
}
],
"strength": "required",
"description": "A coded concept specifying the state of the dispense event.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-dispense-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…status"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MedicationDispense.category",
"path": "MedicationDispense.category",
"short": "Type of medication dispense",
"definition": "Indicates type of medication dispense and where the medication is expected to be consumed or administered.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationDispenseCategory"
}
],
"strength": "preferred",
"description": "A code describing where the dispensed medication is expected to be consumed or administered",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-dispense-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=OBS, moodCode=EVN, code=\"type of medication dispense\"].value"
}
]
},
{
"id": "MedicationDispense.medication[x]",
"path": "MedicationDispense.medication[x]",
"short": "What medication was supplied",
"definition": "Identifies the medication being administered. This is either a link to a resource representing the details of the medication or a simple attribute carrying a code that identifies the medication from a known list of medications.",
"comment": "If only a code is specified, then it needs to be a code for a specific product. If more information is required, then the use of the medication resource is recommended. For example if you require form or lot number, then you must reference the Medication resource. .",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationCode"
}
],
"strength": "example",
"description": "A coded concept identifying which substance or product can be dispensed",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…code"
},
{
"identity": "v2",
"map": "RXD-2-Dispense/Give Code"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRD].role"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "MedicationDispense.subject",
"path": "MedicationDispense.subject",
"short": "Who the dispense is for",
"definition": "A link to a resource representing the person or the group to whom the medication will be given.",
"comment": "SubstanceAdministration->subject->Patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…subject"
},
{
"identity": "v2",
"map": "PID-3-Patient ID List"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role[classCode=PAT]"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MedicationDispense.context",
"path": "MedicationDispense.context",
"short": "Encounter / Episode associated with event",
"definition": "The encounter or episode of care that establishes the context for this event.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…context"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN, code=\"type of encounter or episode\"]"
}
]
},
{
"id": "MedicationDispense.supportingInformation",
"path": "MedicationDispense.supportingInformation",
"short": "Information that supports the dispensing of the medication",
"definition": "Additional information that supports the medication being dispensed.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=PERT].target[A_SupportingClinicalStatement CMET minimal with many different choices of classCodes(ORG, ENC, PROC, SPLY, SBADM, OBS) and each of the act class codes draws from one or more of the following moodCodes (EVN, DEF, INT PRMS, RQO, PRP, APT, ARQ, GOL)]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "MedicationDispense.performer",
"path": "MedicationDispense.performer",
"short": "Who performed event",
"definition": "Indicates who or what performed the event. It should be assumed that the performer is the dispenser of the medication.",
"comment": "The performer will be reviewed as part of STU4.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…performer"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF]"
}
]
},
{
"id": "MedicationDispense.performer.actor",
"path": "MedicationDispense.performer.actor",
"short": "Individual who was performing",
"definition": "The device, practitioner, etc. who performed the action. It should be assumed that the actor is the dispenser of the medication.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"mapping": [
{
"identity": "workflow",
"map": "….actor"
},
{
"identity": "rim",
"map": ".role"
}
]
},
{
"id": "MedicationDispense.performer.onBehalfOf",
"path": "MedicationDispense.performer.onBehalfOf",
"short": "Organization organization was acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "….onBehalfOf"
},
{
"identity": "rim",
"map": ".role.scopingOrganization"
}
]
},
{
"id": "MedicationDispense.authorizingPrescription",
"path": "MedicationDispense.authorizingPrescription",
"short": "Medication order that authorizes the dispense",
"definition": "Indicates the medication order that is being dispensed against.",
"comment": "Maps to basedOn in Event logical model.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…basedOn"
},
{
"identity": "v2",
"map": "ORC-2 Placer Order Number"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target[moodCode=RQO]"
}
]
},
{
"id": "MedicationDispense.type",
"path": "MedicationDispense.type",
"short": "Trial fill, partial fill, emergency fill, etc.",
"definition": "Indicates the type of dispensing event that is performed. For example, Trial Fill, Completion of Trial, Partial Fill, Emergency Fill, Samples, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationDispenseType"
}
],
"strength": "example",
"description": "Indicates the type of dispensing event that is performed. For example, Trial Fill, Completion of Trial, Partial Fill, Emergency Fill, Samples, etc.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-ActPharmacySupplyType"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXD-33-Dispense Type"
},
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "MedicationDispense.quantity",
"path": "MedicationDispense.quantity",
"short": "Amount dispensed",
"definition": "The amount of medication that has been dispensed. Includes unit of measure.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "RXD-4-Actual Dispense Amount / RXD-5.1-Actual Dispense Units.code / RXD-5.3-Actual Dispense Units.name of coding system"
},
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "MedicationDispense.daysSupply",
"path": "MedicationDispense.daysSupply",
"short": "Amount of medication expressed as a timing amount",
"definition": "The amount of medication expressed as a timing amount.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "TQ1.6 Timing/Quantity Segment Service Duration.\rPrior to v2.5, ORC.7.3 Common Order Segment / Quantity/Timing / Duration component. This is a formatted string, first character for the time unit (e.g., D=days), followed by the value. For example, “D14” represents “14 days supply”\rFrom v2.5 on, TQ1.6 Timing/Quantity Segment / Service Duration. This is a CQ data type ( ^ ), thus for days supply, assuming the unit of measure is “days”, the numeric value is TQ1.6.1 (…|14^\rFor backwards compatibility, ORC.7 was permitted through v2.6. Both forms (field and segment) may be present in v2.5, v2.5.1, and v2.6"
},
{
"identity": "rim",
"map": "effectiveUseTime"
}
]
},
{
"id": "MedicationDispense.whenPrepared",
"path": "MedicationDispense.whenPrepared",
"short": "When product was packaged and reviewed",
"definition": "The time when the dispensed product was packaged and reviewed.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "RXD-3-Date/Time Dispensed"
},
{
"identity": "rim",
"map": ".effectiveTime[xmi:type=IVL_TS].low"
}
]
},
{
"id": "MedicationDispense.whenHandedOver",
"path": "MedicationDispense.whenHandedOver",
"short": "When product was given out",
"definition": "The time the dispensed product was provided to the patient or their representative.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…occurrenceDateTime"
},
{
"identity": "v2",
"map": "RXD-3-Date/Time Dispensed"
},
{
"identity": "rim",
"map": ".effectiveTime[xmi:type=IVL_TS].high"
}
]
},
{
"id": "MedicationDispense.destination",
"path": "MedicationDispense.destination",
"short": "Where the medication was sent",
"definition": "Identification of the facility/location where the medication was shipped to, as part of the dispense event.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"mapping": [
{
"identity": "v2",
"map": "RXD-13 Dispense-to Location; RXD-30 Dispense to Pharmacy; RXD-31 Dispense to Pharmacy Address"
},
{
"identity": "rim",
"map": ".participation[typeCode=DST].role"
}
]
},
{
"id": "MedicationDispense.receiver",
"path": "MedicationDispense.receiver",
"short": "Who collected the medication",
"definition": "Identifies the person who picked up the medication. This will usually be a patient or their caregiver, but some cases exist where it can be a healthcare professional.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=RCV].role"
}
]
},
{
"id": "MedicationDispense.note",
"path": "MedicationDispense.note",
"short": "Information about the dispense",
"definition": "Extra information about the dispense that could not be conveyed in the other attributes.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…note"
},
{
"identity": "v2",
"map": "RXD-9 Dispense Notes"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=ACT,moodCode=EVN]"
}
]
},
{
"id": "MedicationDispense.dosageInstruction",
"path": "MedicationDispense.dosageInstruction",
"short": "How the medication is to be used by the patient or administered by the caregiver",
"definition": "Indicates how the medication is to be used by the patient.",
"comment": "When the dose or rate is intended to change over the entire administration period (e.g. Tapering dose prescriptions), multiple instances of dosage instructions will need to be supplied to convey the different doses/rates.\rThe pharmacist reviews the medication order prior to dispense and updates the dosageInstruction based on the actual product being dispensed.",
"min": 0,
"max": "*",
"type": [
{
"code": "Dosage"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=SBADM, moodCode=INT]"
}
]
},
{
"id": "MedicationDispense.substitution",
"path": "MedicationDispense.substitution",
"short": "Whether a substitution was performed on the dispense",
"definition": "Indicates whether or not substitution was made as part of the dispense. In some cases substitution will be expected but does not happen, in other cases substitution is not expected but does happen. This block explains what substitution did or did not happen and why. If nothing is specified, substitution was not done.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=SUBST, moodCode=EVN]"
}
]
},
{
"id": "MedicationDispense.substitution.wasSubstituted",
"path": "MedicationDispense.substitution.wasSubstituted",
"short": "Whether a substitution was or was not performed on the dispense",
"definition": "True if the dispenser dispensed a different drug or product from what was prescribed.",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"mapping": [
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "MedicationDispense.substitution.type",
"path": "MedicationDispense.substitution.type",
"short": "Code signifying whether a different drug was dispensed from what was prescribed",
"definition": "A code signifying whether a different drug was dispensed from what was prescribed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationIntendedSubstitutionType"
}
],
"strength": "example",
"description": "A coded concept describing whether a different medicinal product may be dispensed other than the product as specified exactly in the prescription",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-ActSubstanceAdminSubstitutionCode"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXO-9-Allow Substitutions / RXE-9-Substitution Status"
},
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "MedicationDispense.substitution.reason",
"path": "MedicationDispense.substitution.reason",
"short": "Why was substitution made",
"definition": "Indicates the reason for the substitution of (or lack of substitution) from what was prescribed.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationIntendedSubstitutionReason"
}
],
"strength": "example",
"description": "A coded concept describing the reason that a different medication should (or should not) be substituted from what was prescribed",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-SubstanceAdminSubstitutionReason"
}
},
"mapping": [
{
"identity": "rim",
"map": ".reasonCode"
}
]
},
{
"id": "MedicationDispense.substitution.responsibleParty",
"path": "MedicationDispense.substitution.responsibleParty",
"short": "Who is responsible for the substitution",
"definition": "The person or organization that has primary responsibility for the substitution.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=PFM].role[classCode=ASSIGN]"
}
]
},
{
"id": "MedicationDispense.detectedIssue",
"path": "MedicationDispense.detectedIssue",
"short": "Clinical issue with action",
"definition": "Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, duplicate therapy, dosage alert etc.",
"alias": [
"Contraindication",
"Drug Utilization Review (DUR)",
"Alert"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DetectedIssue"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=ALRT,moodCode=EVN].value"
}
]
},
{
"id": "MedicationDispense.notDone",
"path": "MedicationDispense.notDone",
"short": "Whether the dispense was or was not performed",
"definition": "True if the dispense was not performed for some reason.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…notDone"
},
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "MedicationDispense.notDoneReason[x]",
"path": "MedicationDispense.notDoneReason[x]",
"short": "Why a dispense was not performed",
"definition": "Indicates the reason why a dispense was not performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DetectedIssue"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…notDoneReason"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON]/target[classCode=OBS,moodCode=EVN, code=\"not done reason\"].value"
}
]
},
{
"id": "MedicationDispense.eventHistory",
"path": "MedicationDispense.eventHistory",
"short": "A list of releveant lifecycle events",
"definition": "A summary of the events of interest that have occurred, such as when the dispense was verified.",
"comment": "This may not include provenances for all versions of the request – only those deemed “relevant” or important. This SHALL NOT include the Provenance associated with this current version of the resource. (If that provenance is deemed to be a “relevant” change, it will need to be added as part of a later update. Until then, it can be queried directly as the Provenance that points to this version using _revinclude All Provenances should have some historical version of this Request as their subject.).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/MedicationRequest",
"resource": {
"resourceType": "StructureDefinition",
"id": "MedicationRequest",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints MedicationRequest DomainResource Ordering of medication for patient or group
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..* Identifier External ids for this request
definition Σ 0..* Reference(ActivityDefinition | PlanDefinition) Protocol or definition
basedOn Σ 0..* Reference(CarePlan | MedicationRequest | ProcedureRequest | ReferralRequest) What request fulfills
groupIdentifier Σ 0..1 Identifier Composite request this is part of status ?!Σ 0..1 code active | on-hold | cancelled | completed | entered-in-error | stopped | draft | unknown
MedicationRequestStatus (Required) intent ?!Σ 1..1 code proposal | plan | order | instance-order
MedicationRequestIntent (Required) category 0..1 CodeableConcept Type of medication usage
MedicationRequestCategory (Preferred) priority Σ 0..1 code routine | urgent | stat | asap
MedicationRequestPriority (Required) medication[x] Σ 1..1 Medication to be taken
SNOMED CT Medication Codes (Example) medicationCodeableConcept CodeableConcept medicationReference Reference(Medication) subject Σ 1..1 Reference(Patient | Group) Who or group medication request is for context 0..1 Reference(Encounter | EpisodeOfCare) Created during encounter/admission/stay supportingInformation 0..* Reference(Any) Information to support ordering of the medication
authoredOn Σ 0..1 dateTime When request was initially authored requester ΣI 0..1 BackboneElement Who/What requested the Request
+ onBehalfOf can only be specified if agent is practitioner or device agent Σ 1..1 Reference(Practitioner | Organization | Patient | RelatedPerson | Device) Who ordered the initial medication(s) onBehalfOf ΣI 0..1 Reference(Organization) Organization agent is acting for recorder 0..1 Reference(Practitioner) Person who entered the request reasonCode 0..* CodeableConcept Reason or indication for writing the prescription
Condition/Problem/Diagnosis Codes (Example)
reasonReference 0..* Reference(Condition | Observation) Condition or Observation that supports why the prescription is being written
note 0..* Annotation Information about the prescription
dosageInstruction 0..* Dosage How the medication should be taken
dispenseRequest 0..1 BackboneElement Medication supply authorization validityPeriod 0..1 Period Time period supply is authorized for numberOfRepeatsAllowed 0..1 positiveInt Number of refills authorized quantity 0..1 SimpleQuantity Amount of medication to supply per dispense expectedSupplyDuration 0..1 Duration Number of days supply per dispense performer 0..1 Reference(Organization) Intended dispenser substitution 0..1 BackboneElement Any restrictions on medication substitution allowed ?! 1..1 boolean Whether substitution is allowed or not reason 0..1 CodeableConcept Why should (not) substitution be made
SubstanceAdminSubstitutionReason (Example) priorPrescription 0..1 Reference(MedicationRequest) An order/prescription that is being replaced detectedIssue 0..* Reference(DetectedIssue) Clinical Issue with action
eventHistory 0..* Reference(Provenance) A list of events of interest in the lifecycle
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "phx"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/MedicationRequest",
"name": "MedicationRequest",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Pharmacy)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/medication/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for MedicationRequest Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "script10.6",
"uri": "http://ncpdp.org/SCRIPT10_6",
"name": "Mapping to NCPDP SCRIPT 10.6"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "MedicationRequest",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "MedicationRequest",
"path": "MedicationRequest",
"short": "Ordering of medication for patient or group",
"definition": "An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called \"MedicationRequest\" rather than \"MedicationPrescription\" or \"MedicationOrder\" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns.",
"alias": [
"Prescription",
"Order"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "..Request"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx"
},
{
"identity": "rim",
"map": "CombinedMedicationRequest"
},
{
"identity": "w5",
"map": "clinical.medication"
}
]
},
{
"id": "MedicationRequest.id",
"path": "MedicationRequest.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "MedicationRequest.meta",
"path": "MedicationRequest.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "MedicationRequest.implicitRules",
"path": "MedicationRequest.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "MedicationRequest.language",
"path": "MedicationRequest.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "MedicationRequest.text",
"path": "MedicationRequest.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "MedicationRequest.contained",
"path": "MedicationRequest.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationRequest.extension",
"path": "MedicationRequest.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationRequest.modifierExtension",
"path": "MedicationRequest.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationRequest.identifier",
"path": "MedicationRequest.identifier",
"short": "External ids for this request",
"definition": "This records identifiers associated with this medication request that are defined by business processes and/or used to refer to it when a direct URL reference to the resource itself is not appropriate. For example a re-imbursement system might issue its own id for each prescription that is created. This is particularly important where FHIR only provides part of an entire workflow process where records must be tracked through an entire system.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…identifer"
},
{
"identity": "script10.6",
"map": "Message/Header/PrescriberOrderNumber"
},
{
"identity": "v2",
"map": "ORC-2-Placer Order Number / ORC-3-Filler Order Number"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MedicationRequest.definition",
"path": "MedicationRequest.definition",
"short": "Protocol or definition",
"definition": "Protocol or definition followed by this request.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…definition"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target[classCode=unspecified]"
}
]
},
{
"id": "MedicationRequest.basedOn",
"path": "MedicationRequest.basedOn",
"short": "What request fulfills",
"definition": "A plan or request that is fulfilled in whole or in part by this medication request.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…basedOn"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target[classCode=SBADM or PROC or PCPR or OBS, moodCode=RQO orPLAN or PRP]"
}
]
},
{
"id": "MedicationRequest.groupIdentifier",
"path": "MedicationRequest.groupIdentifier",
"short": "Composite request this is part of",
"definition": "A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition or prescription.",
"requirements": "Requests are linked either by a \"basedOn\" relationship (i.e. one request is fulfilling another) or by having a common requisition. Requests that are part of the same requisition are generally treated independently from the perspective of changing their state or maintaining them after initial creation.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…groupIdentifier"
},
{
"identity": "rim",
"map": ".outboundRelationship(typeCode=COMP].target[classCode=SBADM, moodCode=INT].id"
}
]
},
{
"id": "MedicationRequest.status",
"path": "MedicationRequest.status",
"short": "active | on-hold | cancelled | completed | entered-in-error | stopped | draft | unknown",
"definition": "A code specifying the current state of the order. Generally this will be active or completed state.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationRequestStatus"
}
],
"strength": "required",
"description": "A coded concept specifying the state of the prescribing event. Describes the lifecycle of the prescription",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-request-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…status"
},
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MedicationRequest.intent",
"path": "MedicationRequest.intent",
"short": "proposal | plan | order | instance-order",
"definition": "Whether the request is a proposal, plan, or an original order.",
"comment": "It is expected that the type of requester will be restricted for different stages of a MedicationRequest. For example, Proposals can be created by a patient, relatedPerson, Practitioner or Device. Plans can be created by Practitioners, Patients, RelatedPersons and Devices. Original orders can be created by a Practitioner only.\r\rAn instance-order is an instantiation of a request or order and may be used to populate Medication Administration Record.\n\nThis element is labeled as a modifier because the intent alters when and how the resource is actually applicable.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationRequestIntent"
}
],
"strength": "required",
"description": "The kind of medication order",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-request-intent"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…intent"
},
{
"identity": "rim",
"map": ".moodCode (nuances beyond PRP/PLAN/RQO would need to be elsewhere)"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "MedicationRequest.category",
"path": "MedicationRequest.category",
"short": "Type of medication usage",
"definition": "Indicates the type of medication order and where the medication is expected to be consumed or administered.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationRequestCategory"
}
],
"strength": "preferred",
"description": "A coded concept identifying where the medication ordered is expected to be consumed or administered",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-request-category"
}
},
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Directions\r\ror \r\rMessage/Body/NewRx/MedicationPrescribed/StructuredSIG"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=OBS, moodCode=EVN, code=\"type of medication usage\"].value"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "MedicationRequest.priority",
"path": "MedicationRequest.priority",
"short": "routine | urgent | stat | asap",
"definition": "Indicates how quickly the Medication Request should be addressed with respect to other requests.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationRequestPriority"
}
],
"strength": "required",
"description": "Identifies the level of importance to be assigned to actioning the request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-request-priority"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…priority"
},
{
"identity": "rim",
"map": ".priorityCode"
},
{
"identity": "w5",
"map": "grade"
}
]
},
{
"id": "MedicationRequest.medication[x]",
"path": "MedicationRequest.medication[x]",
"short": "Medication to be taken",
"definition": "Identifies the medication being requested. This is a link to a resource that represents the medication which may be the details of the medication or simply an attribute carrying a code that identifies the medication from a known list of medications.",
"comment": "If only a code is specified, then it needs to be a code for a specific product. If more information is required, then the use of the medication resource is recommended. For example, if you require form or lot number or if the medication is compounded or extemporaneously prepared, then you must reference the Medication resource. .",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationCode"
}
],
"strength": "example",
"description": "A coded concept identifying substance or product that can be ordered.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…code"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed\r\rMedication.code.coding.code = Message/Body/NewRx/MedicationPrescribed/DrugCoded/ProductCode\r\rMedication.code.coding.system = Message/Body/NewRx/MedicationPrescribed/DrugCoded/ProductCodeQualifier\r\rMedication.code.coding.display = Message/Body/NewRx/MedicationPrescribed/DrugDescription"
},
{
"identity": "v2",
"map": "RXE-2-Give Code / RXO-1-Requested Give Code / RXC-2-Component Code"
},
{
"identity": "rim",
"map": "consumable.administrableMedication"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "MedicationRequest.subject",
"path": "MedicationRequest.subject",
"short": "Who or group medication request is for",
"definition": "A link to a resource representing the person or set of individuals to whom the medication will be given.",
"comment": "The subject on a medication request is mandatory. For the secondary use case where the actual subject is not provided, there still must be an anonymized subject specified.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…subject"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/Patient\r\r(need detail to link to specific patient … Patient.Identification in SCRIPT)"
},
{
"identity": "v2",
"map": "PID-3-Patient ID List"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MedicationRequest.context",
"path": "MedicationRequest.context",
"short": "Created during encounter/admission/stay",
"definition": "A link to an encounter, or episode of care, that identifies the particular occurrence or set occurrences of contact between patient and health care provider.",
"comment": "SubstanceAdministration->component->EncounterEvent.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…context"
},
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "v2",
"map": "PV1-19-Visit Number"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN, code=\"type of encounter or episode\"]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "MedicationRequest.supportingInformation",
"path": "MedicationRequest.supportingInformation",
"short": "Information to support ordering of the medication",
"definition": "Include additional information (for example, patient height and weight) that supports the ordering of the medication.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=PERT].target[A_SupportingClinicalStatement CMET minimal with many different choices of classCodes(ORG, ENC, PROC, SPLY, SBADM, OBS) and each of the act class codes draws from one or more of the following moodCodes (EVN, DEF, INT PRMS, RQO, PRP, APT, ARQ, GOL)]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "MedicationRequest.authoredOn",
"path": "MedicationRequest.authoredOn",
"short": "When request was initially authored",
"definition": "The date (and perhaps time) when the prescription was initially written or authored on.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…authoredOn"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/WrittenDate"
},
{
"identity": "v2",
"map": "RXE-32-Original Order Date/Time / ORC-9-Date/Time of Transaction"
},
{
"identity": "rim",
"map": "author.time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "MedicationRequest.requester",
"path": "MedicationRequest.requester",
"short": "Who/What requested the Request",
"definition": "The individual, organization or device that initiated the request and has responsibility for its activation.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "mps-1",
"severity": "error",
"human": "onBehalfOf can only be specified if agent is practitioner or device",
"expression": "(agent.resolve().empty()) or (agent.resolve() is Device) or (agent.resolve() is Practitioner) or onBehalfOf.exists().not()",
"xpath": "contains(f:agent/f:reference/@value, '/Practitioner/') or contains(f:agent/f:reference/@value, '/Device/') or not(exists(f:onBehalfOf))"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…requester"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "MedicationRequest.requester.id",
"path": "MedicationRequest.requester.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationRequest.requester.extension",
"path": "MedicationRequest.requester.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationRequest.requester.modifierExtension",
"path": "MedicationRequest.requester.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationRequest.requester.agent",
"path": "MedicationRequest.requester.agent",
"short": "Who ordered the initial medication(s)",
"definition": "The healthcare professional responsible for authorizing the initial prescription.",
"comment": "It is expected that the type of requester will be restricted for different stages of a MedicationRequest. For example, Proposals can be created by a patient, relatedPerson, Practitioner or Device. Plans can be created by Practitioners, Patients, RelatedPersons and Devices. Original orders can be created by a Practitioner only.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "….agent"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/Prescriber\r\r(need detail to link to specific prescriber … Prescriber.Identification in SCRIPT)"
},
{
"identity": "v2",
"map": "RXE-13-Ordering Provider's DEA Number / RXO-14-Ordering Provider's DEA Number / RXE-14-Pharmacist/Treatment Supplier's Verifier ID / RXO-15-Pharmacist/Treatment Supplier's Verifier ID / ORC-12-Ordering Provider / PRT-5-Participation Person: PRT-4-Participation='OP' (all but last deprecated)"
},
{
"identity": "rim",
"map": ".player"
}
]
},
{
"id": "MedicationRequest.requester.onBehalfOf",
"path": "MedicationRequest.requester.onBehalfOf",
"short": "Organization agent is acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when authoring the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"condition": [
"mps-1"
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "….onBehalfOf"
},
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "MedicationRequest.recorder",
"path": "MedicationRequest.recorder",
"short": "Person who entered the request",
"definition": "The person who entered the order on behalf of another individual for example in the case of a verbal or a telephone order.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=TRANS].role[classCode=ASSIGNED].code (HealthcareProviderType)"
},
{
"identity": "w5",
"map": "who"
}
]
},
{
"id": "MedicationRequest.reasonCode",
"path": "MedicationRequest.reasonCode",
"short": "Reason or indication for writing the prescription",
"definition": "The reason or the indication for ordering the medication.",
"comment": "This could be a diagnosis code. If a full condition record exists or additional detail is needed, use reasonReference.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationRequestReason"
}
],
"strength": "example",
"description": "A coded concept indicating why the medication was ordered.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/condition-code"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…reasonCode"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Diagnosis/Primary/Value"
},
{
"identity": "v2",
"map": "ORC-16-Order Control Code Reason /RXE-27-Give Indication/RXO-20-Indication / RXD-21-Indication / RXG-22-Indication / RXA-19-Indication"
},
{
"identity": "rim",
"map": "reason.observation.reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MedicationRequest.reasonReference",
"path": "MedicationRequest.reasonReference",
"short": "Condition or Observation that supports why the prescription is being written",
"definition": "Condition or observation that supports why the medication was ordered.",
"comment": "This is a reference to a condition or observation that is the reason for the medication order. If only a code exists, use reasonCode.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…reasonReference"
},
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": "reason.observation[code=ASSERTION].value"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MedicationRequest.note",
"path": "MedicationRequest.note",
"short": "Information about the prescription",
"definition": "Extra information about the prescription that could not be conveyed by the other attributes.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…note"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Note"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=OBS,moodCode=EVN,code=\"annotation\"].value"
}
]
},
{
"id": "MedicationRequest.dosageInstruction",
"path": "MedicationRequest.dosageInstruction",
"short": "How the medication should be taken",
"definition": "Indicates how the medication is to be used by the patient.",
"comment": "There are examples where a medication request may include the option of an oral dose or an Intravenous or Intramuscular dose. For example, \"Ondansetron 8mg orally or IV twice a day as needed for nausea\" or \"Compazine® (prochlorperazine) 5-10mg PO or 25mg PR bid prn nausea or vomiting\". In these cases, two medication requests would be created that could be grouped together. The decision on which dose and route of administration to use is based on the patient's condition at the time the dose is needed.",
"min": 0,
"max": "*",
"type": [
{
"code": "Dosage"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…occurrence[x]"
},
{
"identity": "rim",
"map": "see dosageInstruction mapping"
}
]
},
{
"id": "MedicationRequest.dispenseRequest",
"path": "MedicationRequest.dispenseRequest",
"short": "Medication supply authorization",
"definition": "Indicates the specific details for the dispense or medication supply part of a medication request (also known as a Medication Prescription or Medication Order). Note that this information is not always sent with the order. There may be in some settings (e.g. hospitals) institutional or system support for completing the dispense details in the pharmacy department.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/ExpirationDate"
},
{
"identity": "rim",
"map": "component.supplyEvent"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.id",
"path": "MedicationRequest.dispenseRequest.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.extension",
"path": "MedicationRequest.dispenseRequest.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.modifierExtension",
"path": "MedicationRequest.dispenseRequest.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.validityPeriod",
"path": "MedicationRequest.dispenseRequest.validityPeriod",
"short": "Time period supply is authorized for",
"definition": "This indicates the validity period of a prescription (stale dating the Prescription).",
"comment": "It reflects the prescribers' perspective for the validity of the prescription. Dispenses must not be made against the prescription outside of this period. The lower-bound of the Dispensing Window signifies the earliest date that the prescription can be filled for the first time. If an upper-bound is not specified then the Prescription is open-ended or will default to a stale-date based on regulations.",
"requirements": "Indicates when the Prescription becomes valid, and when it ceases to be a dispensable Prescription.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Refills"
},
{
"identity": "rim",
"map": "effectiveTime"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.numberOfRepeatsAllowed",
"path": "MedicationRequest.dispenseRequest.numberOfRepeatsAllowed",
"short": "Number of refills authorized",
"definition": "An integer indicating the number of times, in addition to the original dispense, (aka refills or repeats) that the patient can receive the prescribed medication. Usage Notes: This integer does not include the original order dispense. This means that if an order indicates dispense 30 tablets plus \"3 repeats\", then the order can be dispensed a total of 4 times and the patient can receive a total of 120 tablets.",
"comment": "If displaying \"number of authorized fills\", add 1 to this number.",
"min": 0,
"max": "1",
"type": [
{
"code": "positiveInt"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Quantity"
},
{
"identity": "v2",
"map": "RXE-12-Number of Refills"
},
{
"identity": "rim",
"map": "repeatNumber"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.quantity",
"path": "MedicationRequest.dispenseRequest.quantity",
"short": "Amount of medication to supply per dispense",
"definition": "The amount that is to be dispensed for one fill.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/DaysSupply"
},
{
"identity": "v2",
"map": "RXD-4-Actual Dispense Amount / RXD-5.1-Actual Dispense Units.code / RXD-5.3-Actual Dispense Units.name of coding system"
},
{
"identity": "rim",
"map": "quantity"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.expectedSupplyDuration",
"path": "MedicationRequest.dispenseRequest.expectedSupplyDuration",
"short": "Number of days supply per dispense",
"definition": "Identifies the period time over which the supplied product is expected to be used, or the length of time the dispense is expected to last.",
"comment": "In some situations, this attribute may be used instead of quantity to identify the amount supplied by how long it is expected to last, rather than the physical quantity issued, e.g. 90 days supply of medication (based on an ordered dosage) When possible, it is always better to specify quantity, as this tends to be more precise. expectedSupplyDuration will always be an estimate that can be influenced by external factors.",
"min": 0,
"max": "1",
"type": [
{
"code": "Duration"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Substitutions"
},
{
"identity": "rim",
"map": "expectedUseTime"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.performer",
"path": "MedicationRequest.dispenseRequest.performer",
"short": "Intended dispenser",
"definition": "Indicates the intended dispensing Organization specified by the prescriber.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=SPLY, moodCode=RQO] .participation[typeCode=PRF].role[scoper.determinerCode=INSTANCE]"
},
{
"identity": "w5",
"map": "who"
}
]
},
{
"id": "MedicationRequest.substitution",
"path": "MedicationRequest.substitution",
"short": "Any restrictions on medication substitution",
"definition": "Indicates whether or not substitution can or should be part of the dispense. In some cases substitution must happen, in other cases substitution must not happen. This block explains the prescriber's intent. If nothing is specified substitution may be done.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "specific values within Message/Body/NewRx/MedicationPrescribed/Substitutions"
},
{
"identity": "rim",
"map": "subjectOf.substitutionPersmission"
}
]
},
{
"id": "MedicationRequest.substitution.id",
"path": "MedicationRequest.substitution.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationRequest.substitution.extension",
"path": "MedicationRequest.substitution.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MedicationRequest.substitution.modifierExtension",
"path": "MedicationRequest.substitution.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationRequest.substitution.allowed",
"path": "MedicationRequest.substitution.allowed",
"short": "Whether substitution is allowed or not",
"definition": "True if the prescriber allows a different drug to be dispensed from what was prescribed.",
"comment": "This element is labeled as a modifer because whether substitution is allow or not cannot be ignored.",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"mapping": [
{
"identity": "script10.6",
"map": "specific values within Message/Body/NewRx/MedicationPrescribed/Substitutions"
},
{
"identity": "v2",
"map": "RXO-9-Allow Substitutions / RXE-9-Substitution Status"
},
{
"identity": "rim",
"map": "code"
}
]
},
{
"id": "MedicationRequest.substitution.reason",
"path": "MedicationRequest.substitution.reason",
"short": "Why should (not) substitution be made",
"definition": "Indicates the reason for the substitution, or why substitution must or must not be performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationIntendedSubstitutionReason"
}
],
"strength": "example",
"description": "A coded concept describing the reason that a different medication should (or should not) be substituted from what was prescribed.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-SubstanceAdminSubstitutionReason"
}
},
"mapping": [
{
"identity": "script10.6",
"map": "not mapped"
},
{
"identity": "v2",
"map": "RXE-9 Substition status"
},
{
"identity": "rim",
"map": "reasonCode"
}
]
},
{
"id": "MedicationRequest.priorPrescription",
"path": "MedicationRequest.priorPrescription",
"short": "An order/prescription that is being replaced",
"definition": "A link to a resource representing an earlier order related order or prescription.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…replaces"
},
{
"identity": "script10.6",
"map": "not mapped"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=?RPLC or ?SUCC]/target[classCode=SBADM,moodCode=RQO]"
}
]
},
{
"id": "MedicationRequest.detectedIssue",
"path": "MedicationRequest.detectedIssue",
"short": "Clinical Issue with action",
"definition": "Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, duplicate therapy, dosage alert etc.",
"alias": [
"Contraindication",
"Drug Utilization Review (DUR)",
"Alert"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DetectedIssue"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=ALRT,moodCode=EVN].value"
}
]
},
{
"id": "MedicationRequest.eventHistory",
"path": "MedicationRequest.eventHistory",
"short": "A list of events of interest in the lifecycle",
"definition": "Links to Provenance records for past versions of this resource or fulfilling request or event resources that identify key state transitions or updates that are likely to be relevant to a user looking at the current version of the resource.",
"comment": "This may not include provenances for all versions of the request – only those deemed “relevant” or important. This SHALL NOT include the Provenance associated with this current version of the resource. (If that provenance is deemed to be a “relevant” change, it will need to be added as part of a later update. Until then, it can be queried directly as the Provenance that points to this version using _revinclude All Provenances should have some historical version of this Request as their subject.).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…relevantHistory"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
}
]
},
"differential": {
"element": [
{
"id": "MedicationRequest",
"path": "MedicationRequest",
"short": "Ordering of medication for patient or group",
"definition": "An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called \"MedicationRequest\" rather than \"MedicationPrescription\" or \"MedicationOrder\" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns.",
"alias": [
"Prescription",
"Order"
],
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "..Request"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx"
},
{
"identity": "rim",
"map": "CombinedMedicationRequest"
},
{
"identity": "w5",
"map": "clinical.medication"
}
]
},
{
"id": "MedicationRequest.identifier",
"path": "MedicationRequest.identifier",
"short": "External ids for this request",
"definition": "This records identifiers associated with this medication request that are defined by business processes and/or used to refer to it when a direct URL reference to the resource itself is not appropriate. For example a re-imbursement system might issue its own id for each prescription that is created. This is particularly important where FHIR only provides part of an entire workflow process where records must be tracked through an entire system.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…identifer"
},
{
"identity": "script10.6",
"map": "Message/Header/PrescriberOrderNumber"
},
{
"identity": "v2",
"map": "ORC-2-Placer Order Number / ORC-3-Filler Order Number"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MedicationRequest.definition",
"path": "MedicationRequest.definition",
"short": "Protocol or definition",
"definition": "Protocol or definition followed by this request.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…definition"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target[classCode=unspecified]"
}
]
},
{
"id": "MedicationRequest.basedOn",
"path": "MedicationRequest.basedOn",
"short": "What request fulfills",
"definition": "A plan or request that is fulfilled in whole or in part by this medication request.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…basedOn"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target[classCode=SBADM or PROC or PCPR or OBS, moodCode=RQO orPLAN or PRP]"
}
]
},
{
"id": "MedicationRequest.groupIdentifier",
"path": "MedicationRequest.groupIdentifier",
"short": "Composite request this is part of",
"definition": "A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition or prescription.",
"requirements": "Requests are linked either by a \"basedOn\" relationship (i.e. one request is fulfilling another) or by having a common requisition. Requests that are part of the same requisition are generally treated independently from the perspective of changing their state or maintaining them after initial creation.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…groupIdentifier"
},
{
"identity": "rim",
"map": ".outboundRelationship(typeCode=COMP].target[classCode=SBADM, moodCode=INT].id"
}
]
},
{
"id": "MedicationRequest.status",
"path": "MedicationRequest.status",
"short": "active | on-hold | cancelled | completed | entered-in-error | stopped | draft | unknown",
"definition": "A code specifying the current state of the order. Generally this will be active or completed state.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationRequestStatus"
}
],
"strength": "required",
"description": "A coded concept specifying the state of the prescribing event. Describes the lifecycle of the prescription",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-request-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…status"
},
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MedicationRequest.intent",
"path": "MedicationRequest.intent",
"short": "proposal | plan | order | instance-order",
"definition": "Whether the request is a proposal, plan, or an original order.",
"comment": "It is expected that the type of requester will be restricted for different stages of a MedicationRequest. For example, Proposals can be created by a patient, relatedPerson, Practitioner or Device. Plans can be created by Practitioners, Patients, RelatedPersons and Devices. Original orders can be created by a Practitioner only.\r\rAn instance-order is an instantiation of a request or order and may be used to populate Medication Administration Record.\n\nThis element is labeled as a modifier because the intent alters when and how the resource is actually applicable.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationRequestIntent"
}
],
"strength": "required",
"description": "The kind of medication order",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-request-intent"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…intent"
},
{
"identity": "rim",
"map": ".moodCode (nuances beyond PRP/PLAN/RQO would need to be elsewhere)"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "MedicationRequest.category",
"path": "MedicationRequest.category",
"short": "Type of medication usage",
"definition": "Indicates the type of medication order and where the medication is expected to be consumed or administered.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationRequestCategory"
}
],
"strength": "preferred",
"description": "A coded concept identifying where the medication ordered is expected to be consumed or administered",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-request-category"
}
},
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Directions\r\ror \r\rMessage/Body/NewRx/MedicationPrescribed/StructuredSIG"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=OBS, moodCode=EVN, code=\"type of medication usage\"].value"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "MedicationRequest.priority",
"path": "MedicationRequest.priority",
"short": "routine | urgent | stat | asap",
"definition": "Indicates how quickly the Medication Request should be addressed with respect to other requests.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationRequestPriority"
}
],
"strength": "required",
"description": "Identifies the level of importance to be assigned to actioning the request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-request-priority"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…priority"
},
{
"identity": "rim",
"map": ".priorityCode"
},
{
"identity": "w5",
"map": "grade"
}
]
},
{
"id": "MedicationRequest.medication[x]",
"path": "MedicationRequest.medication[x]",
"short": "Medication to be taken",
"definition": "Identifies the medication being requested. This is a link to a resource that represents the medication which may be the details of the medication or simply an attribute carrying a code that identifies the medication from a known list of medications.",
"comment": "If only a code is specified, then it needs to be a code for a specific product. If more information is required, then the use of the medication resource is recommended. For example, if you require form or lot number or if the medication is compounded or extemporaneously prepared, then you must reference the Medication resource. .",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationCode"
}
],
"strength": "example",
"description": "A coded concept identifying substance or product that can be ordered.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…code"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed\r\rMedication.code.coding.code = Message/Body/NewRx/MedicationPrescribed/DrugCoded/ProductCode\r\rMedication.code.coding.system = Message/Body/NewRx/MedicationPrescribed/DrugCoded/ProductCodeQualifier\r\rMedication.code.coding.display = Message/Body/NewRx/MedicationPrescribed/DrugDescription"
},
{
"identity": "v2",
"map": "RXE-2-Give Code / RXO-1-Requested Give Code / RXC-2-Component Code"
},
{
"identity": "rim",
"map": "consumable.administrableMedication"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "MedicationRequest.subject",
"path": "MedicationRequest.subject",
"short": "Who or group medication request is for",
"definition": "A link to a resource representing the person or set of individuals to whom the medication will be given.",
"comment": "The subject on a medication request is mandatory. For the secondary use case where the actual subject is not provided, there still must be an anonymized subject specified.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…subject"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/Patient\r\r(need detail to link to specific patient … Patient.Identification in SCRIPT)"
},
{
"identity": "v2",
"map": "PID-3-Patient ID List"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MedicationRequest.context",
"path": "MedicationRequest.context",
"short": "Created during encounter/admission/stay",
"definition": "A link to an encounter, or episode of care, that identifies the particular occurrence or set occurrences of contact between patient and health care provider.",
"comment": "SubstanceAdministration->component->EncounterEvent.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…context"
},
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "v2",
"map": "PV1-19-Visit Number"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN, code=\"type of encounter or episode\"]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "MedicationRequest.supportingInformation",
"path": "MedicationRequest.supportingInformation",
"short": "Information to support ordering of the medication",
"definition": "Include additional information (for example, patient height and weight) that supports the ordering of the medication.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=PERT].target[A_SupportingClinicalStatement CMET minimal with many different choices of classCodes(ORG, ENC, PROC, SPLY, SBADM, OBS) and each of the act class codes draws from one or more of the following moodCodes (EVN, DEF, INT PRMS, RQO, PRP, APT, ARQ, GOL)]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "MedicationRequest.authoredOn",
"path": "MedicationRequest.authoredOn",
"short": "When request was initially authored",
"definition": "The date (and perhaps time) when the prescription was initially written or authored on.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…authoredOn"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/WrittenDate"
},
{
"identity": "v2",
"map": "RXE-32-Original Order Date/Time / ORC-9-Date/Time of Transaction"
},
{
"identity": "rim",
"map": "author.time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "MedicationRequest.requester",
"path": "MedicationRequest.requester",
"short": "Who/What requested the Request",
"definition": "The individual, organization or device that initiated the request and has responsibility for its activation.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "mps-1",
"severity": "error",
"human": "onBehalfOf can only be specified if agent is practitioner or device",
"expression": "(agent.resolve().empty()) or (agent.resolve() is Device) or (agent.resolve() is Practitioner) or onBehalfOf.exists().not()",
"xpath": "contains(f:agent/f:reference/@value, '/Practitioner/') or contains(f:agent/f:reference/@value, '/Device/') or not(exists(f:onBehalfOf))"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…requester"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "MedicationRequest.requester.agent",
"path": "MedicationRequest.requester.agent",
"short": "Who ordered the initial medication(s)",
"definition": "The healthcare professional responsible for authorizing the initial prescription.",
"comment": "It is expected that the type of requester will be restricted for different stages of a MedicationRequest. For example, Proposals can be created by a patient, relatedPerson, Practitioner or Device. Plans can be created by Practitioners, Patients, RelatedPersons and Devices. Original orders can be created by a Practitioner only.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "….agent"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/Prescriber\r\r(need detail to link to specific prescriber … Prescriber.Identification in SCRIPT)"
},
{
"identity": "v2",
"map": "RXE-13-Ordering Provider's DEA Number / RXO-14-Ordering Provider's DEA Number / RXE-14-Pharmacist/Treatment Supplier's Verifier ID / RXO-15-Pharmacist/Treatment Supplier's Verifier ID / ORC-12-Ordering Provider / PRT-5-Participation Person: PRT-4-Participation='OP' (all but last deprecated)"
},
{
"identity": "rim",
"map": ".player"
}
]
},
{
"id": "MedicationRequest.requester.onBehalfOf",
"path": "MedicationRequest.requester.onBehalfOf",
"short": "Organization agent is acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when authoring the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"condition": [
"mps-1"
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "….onBehalfOf"
},
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "MedicationRequest.recorder",
"path": "MedicationRequest.recorder",
"short": "Person who entered the request",
"definition": "The person who entered the order on behalf of another individual for example in the case of a verbal or a telephone order.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=TRANS].role[classCode=ASSIGNED].code (HealthcareProviderType)"
},
{
"identity": "w5",
"map": "who"
}
]
},
{
"id": "MedicationRequest.reasonCode",
"path": "MedicationRequest.reasonCode",
"short": "Reason or indication for writing the prescription",
"definition": "The reason or the indication for ordering the medication.",
"comment": "This could be a diagnosis code. If a full condition record exists or additional detail is needed, use reasonReference.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationRequestReason"
}
],
"strength": "example",
"description": "A coded concept indicating why the medication was ordered.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/condition-code"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…reasonCode"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Diagnosis/Primary/Value"
},
{
"identity": "v2",
"map": "ORC-16-Order Control Code Reason /RXE-27-Give Indication/RXO-20-Indication / RXD-21-Indication / RXG-22-Indication / RXA-19-Indication"
},
{
"identity": "rim",
"map": "reason.observation.reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MedicationRequest.reasonReference",
"path": "MedicationRequest.reasonReference",
"short": "Condition or Observation that supports why the prescription is being written",
"definition": "Condition or observation that supports why the medication was ordered.",
"comment": "This is a reference to a condition or observation that is the reason for the medication order. If only a code exists, use reasonCode.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…reasonReference"
},
{
"identity": "script10.6",
"map": "no mapping"
},
{
"identity": "rim",
"map": "reason.observation[code=ASSERTION].value"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MedicationRequest.note",
"path": "MedicationRequest.note",
"short": "Information about the prescription",
"definition": "Extra information about the prescription that could not be conveyed by the other attributes.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…note"
},
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Note"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=OBS,moodCode=EVN,code=\"annotation\"].value"
}
]
},
{
"id": "MedicationRequest.dosageInstruction",
"path": "MedicationRequest.dosageInstruction",
"short": "How the medication should be taken",
"definition": "Indicates how the medication is to be used by the patient.",
"comment": "There are examples where a medication request may include the option of an oral dose or an Intravenous or Intramuscular dose. For example, \"Ondansetron 8mg orally or IV twice a day as needed for nausea\" or \"Compazine® (prochlorperazine) 5-10mg PO or 25mg PR bid prn nausea or vomiting\". In these cases, two medication requests would be created that could be grouped together. The decision on which dose and route of administration to use is based on the patient's condition at the time the dose is needed.",
"min": 0,
"max": "*",
"type": [
{
"code": "Dosage"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…occurrence[x]"
},
{
"identity": "rim",
"map": "see dosageInstruction mapping"
}
]
},
{
"id": "MedicationRequest.dispenseRequest",
"path": "MedicationRequest.dispenseRequest",
"short": "Medication supply authorization",
"definition": "Indicates the specific details for the dispense or medication supply part of a medication request (also known as a Medication Prescription or Medication Order). Note that this information is not always sent with the order. There may be in some settings (e.g. hospitals) institutional or system support for completing the dispense details in the pharmacy department.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/ExpirationDate"
},
{
"identity": "rim",
"map": "component.supplyEvent"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.validityPeriod",
"path": "MedicationRequest.dispenseRequest.validityPeriod",
"short": "Time period supply is authorized for",
"definition": "This indicates the validity period of a prescription (stale dating the Prescription).",
"comment": "It reflects the prescribers' perspective for the validity of the prescription. Dispenses must not be made against the prescription outside of this period. The lower-bound of the Dispensing Window signifies the earliest date that the prescription can be filled for the first time. If an upper-bound is not specified then the Prescription is open-ended or will default to a stale-date based on regulations.",
"requirements": "Indicates when the Prescription becomes valid, and when it ceases to be a dispensable Prescription.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Refills"
},
{
"identity": "rim",
"map": "effectiveTime"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.numberOfRepeatsAllowed",
"path": "MedicationRequest.dispenseRequest.numberOfRepeatsAllowed",
"short": "Number of refills authorized",
"definition": "An integer indicating the number of times, in addition to the original dispense, (aka refills or repeats) that the patient can receive the prescribed medication. Usage Notes: This integer does not include the original order dispense. This means that if an order indicates dispense 30 tablets plus \"3 repeats\", then the order can be dispensed a total of 4 times and the patient can receive a total of 120 tablets.",
"comment": "If displaying \"number of authorized fills\", add 1 to this number.",
"min": 0,
"max": "1",
"type": [
{
"code": "positiveInt"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Quantity"
},
{
"identity": "v2",
"map": "RXE-12-Number of Refills"
},
{
"identity": "rim",
"map": "repeatNumber"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.quantity",
"path": "MedicationRequest.dispenseRequest.quantity",
"short": "Amount of medication to supply per dispense",
"definition": "The amount that is to be dispensed for one fill.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/DaysSupply"
},
{
"identity": "v2",
"map": "RXD-4-Actual Dispense Amount / RXD-5.1-Actual Dispense Units.code / RXD-5.3-Actual Dispense Units.name of coding system"
},
{
"identity": "rim",
"map": "quantity"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.expectedSupplyDuration",
"path": "MedicationRequest.dispenseRequest.expectedSupplyDuration",
"short": "Number of days supply per dispense",
"definition": "Identifies the period time over which the supplied product is expected to be used, or the length of time the dispense is expected to last.",
"comment": "In some situations, this attribute may be used instead of quantity to identify the amount supplied by how long it is expected to last, rather than the physical quantity issued, e.g. 90 days supply of medication (based on an ordered dosage) When possible, it is always better to specify quantity, as this tends to be more precise. expectedSupplyDuration will always be an estimate that can be influenced by external factors.",
"min": 0,
"max": "1",
"type": [
{
"code": "Duration"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "Message/Body/NewRx/MedicationPrescribed/Substitutions"
},
{
"identity": "rim",
"map": "expectedUseTime"
}
]
},
{
"id": "MedicationRequest.dispenseRequest.performer",
"path": "MedicationRequest.dispenseRequest.performer",
"short": "Intended dispenser",
"definition": "Indicates the intended dispensing Organization specified by the prescriber.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=SPLY, moodCode=RQO] .participation[typeCode=PRF].role[scoper.determinerCode=INSTANCE]"
},
{
"identity": "w5",
"map": "who"
}
]
},
{
"id": "MedicationRequest.substitution",
"path": "MedicationRequest.substitution",
"short": "Any restrictions on medication substitution",
"definition": "Indicates whether or not substitution can or should be part of the dispense. In some cases substitution must happen, in other cases substitution must not happen. This block explains the prescriber's intent. If nothing is specified substitution may be done.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "script10.6",
"map": "specific values within Message/Body/NewRx/MedicationPrescribed/Substitutions"
},
{
"identity": "rim",
"map": "subjectOf.substitutionPersmission"
}
]
},
{
"id": "MedicationRequest.substitution.allowed",
"path": "MedicationRequest.substitution.allowed",
"short": "Whether substitution is allowed or not",
"definition": "True if the prescriber allows a different drug to be dispensed from what was prescribed.",
"comment": "This element is labeled as a modifer because whether substitution is allow or not cannot be ignored.",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"mapping": [
{
"identity": "script10.6",
"map": "specific values within Message/Body/NewRx/MedicationPrescribed/Substitutions"
},
{
"identity": "v2",
"map": "RXO-9-Allow Substitutions / RXE-9-Substitution Status"
},
{
"identity": "rim",
"map": "code"
}
]
},
{
"id": "MedicationRequest.substitution.reason",
"path": "MedicationRequest.substitution.reason",
"short": "Why should (not) substitution be made",
"definition": "Indicates the reason for the substitution, or why substitution must or must not be performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationIntendedSubstitutionReason"
}
],
"strength": "example",
"description": "A coded concept describing the reason that a different medication should (or should not) be substituted from what was prescribed.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-SubstanceAdminSubstitutionReason"
}
},
"mapping": [
{
"identity": "script10.6",
"map": "not mapped"
},
{
"identity": "v2",
"map": "RXE-9 Substition status"
},
{
"identity": "rim",
"map": "reasonCode"
}
]
},
{
"id": "MedicationRequest.priorPrescription",
"path": "MedicationRequest.priorPrescription",
"short": "An order/prescription that is being replaced",
"definition": "A link to a resource representing an earlier order related order or prescription.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…replaces"
},
{
"identity": "script10.6",
"map": "not mapped"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=?RPLC or ?SUCC]/target[classCode=SBADM,moodCode=RQO]"
}
]
},
{
"id": "MedicationRequest.detectedIssue",
"path": "MedicationRequest.detectedIssue",
"short": "Clinical Issue with action",
"definition": "Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, duplicate therapy, dosage alert etc.",
"alias": [
"Contraindication",
"Drug Utilization Review (DUR)",
"Alert"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DetectedIssue"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=ALRT,moodCode=EVN].value"
}
]
},
{
"id": "MedicationRequest.eventHistory",
"path": "MedicationRequest.eventHistory",
"short": "A list of events of interest in the lifecycle",
"definition": "Links to Provenance records for past versions of this resource or fulfilling request or event resources that identify key state transitions or updates that are likely to be relevant to a user looking at the current version of the resource.",
"comment": "This may not include provenances for all versions of the request – only those deemed “relevant” or important. This SHALL NOT include the Provenance associated with this current version of the resource. (If that provenance is deemed to be a “relevant” change, it will need to be added as part of a later update. Until then, it can be queried directly as the Provenance that points to this version using _revinclude All Provenances should have some historical version of this Request as their subject.).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…relevantHistory"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/MedicationStatement",
"resource": {
"resourceType": "StructureDefinition",
"id": "MedicationStatement",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints MedicationStatement I DomainResource Record of medication being taken by a patient
+ Reason not taken is only permitted if Taken is No
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier External identifier
basedOn Σ 0..* Reference(MedicationRequest | CarePlan | ProcedureRequest | ReferralRequest) Fulfils plan, proposal or order
partOf Σ 0..* Reference(MedicationAdministration | MedicationDispense | MedicationStatement | Procedure | Observation) Part of referenced event
context Σ 0..1 Reference(Encounter | EpisodeOfCare) Encounter / Episode associated with MedicationStatement status ?!Σ 1..1 code active | completed | entered-in-error | intended | stopped | on-hold
MedicationStatementStatus (Required) category Σ 0..1 CodeableConcept Type of medication usage
MedicationStatementCategory (Preferred) medication[x] Σ 1..1 What medication was taken
SNOMED CT Medication Codes (Example) medicationCodeableConcept CodeableConcept medicationReference Reference(Medication) effective[x] Σ 0..1 The date/time or interval when the medication was taken effectiveDateTime dateTime effectivePeriod Period dateAsserted Σ 0..1 dateTime When the statement was asserted? informationSource 0..1 Reference(Patient | Practitioner | RelatedPerson | Organization) Person or organization that provided the information about the taking of this medication subject Σ 1..1 Reference(Patient | Group) Who is/was taking the medication derivedFrom 0..* Reference(Any) Additional supporting information
taken ?!Σ 1..1 code y | n | unk | na
MedicationStatementTaken (Required) reasonNotTaken I 0..* CodeableConcept True if asserting medication was not given
SNOMED CT Drugs not taken/completed Codes (Example)
reasonCode 0..* CodeableConcept Reason for why the medication is being/was taken
Condition/Problem/Diagnosis Codes (Example)
reasonReference 0..* Reference(Condition | Observation) Condition or observation that supports why the medication is being/was taken
note 0..* Annotation Further information about the statement
dosage 0..* Dosage Details of how medication is/was taken or should be taken
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "phx"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/MedicationStatement",
"name": "MedicationStatement",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Pharmacy)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/medication/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for MedicationStatement Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "MedicationStatement",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "MedicationStatement",
"path": "MedicationStatement",
"short": "Record of medication being taken by a patient",
"definition": "A record of a medication that is being consumed by a patient. A MedicationStatement may indicate that the patient may be taking the medication now, or has taken the medication in the past or will be taking the medication in the future. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay. The medication information may come from sources such as the patient's memory, from a prescription bottle, or from a list of medications the patient, clinician or other party maintains \r\rThe primary difference between a medication statement and a medication administration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication. A medication statement is often, if not always, less specific. There is no required date/time when the medication was administered, in fact we only know that a source has reported the patient is taking this medication, where details such as time, quantity, or rate or even medication product may be incomplete or missing or less precise. As stated earlier, the medication statement information may come from the patient's memory, from a prescription bottle or from a list of medications the patient, clinician or other party maintains. Medication administration is more formal and is not missing detailed information.",
"comment": "When interpreting a medicationStatement, the value of the status and NotTaken needed to be considered:\rMedicationStatement.status + MedicationStatement.wasNotTaken\rStatus=Active + NotTaken=T = Not currently taking\rStatus=Completed + NotTaken=T = Not taken in the past\rStatus=Intended + NotTaken=T = No intention of taking\rStatus=Active + NotTaken=F = Taking, but not as prescribed\rStatus=Active + NotTaken=F = Taking\rStatus=Intended +NotTaken= F = Will be taking (not started)\rStatus=Completed + NotTaken=F = Taken in past\rStatus=In Error + NotTaken=N/A = In Error.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "mst-1",
"severity": "error",
"human": "Reason not taken is only permitted if Taken is No",
"expression": "reasonNotTaken.exists().not() or (taken = 'n')",
"xpath": "not(exists(f:reasonNotTaken)) or f:taken/@value='n'"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "..Event"
},
{
"identity": "rim",
"map": "SubstanceAdministration"
},
{
"identity": "w5",
"map": "clinical.medication"
}
]
},
{
"id": "MedicationStatement.id",
"path": "MedicationStatement.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "MedicationStatement.meta",
"path": "MedicationStatement.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "MedicationStatement.implicitRules",
"path": "MedicationStatement.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "MedicationStatement.language",
"path": "MedicationStatement.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "MedicationStatement.text",
"path": "MedicationStatement.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "MedicationStatement.contained",
"path": "MedicationStatement.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationStatement.extension",
"path": "MedicationStatement.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationStatement.modifierExtension",
"path": "MedicationStatement.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MedicationStatement.identifier",
"path": "MedicationStatement.identifier",
"short": "External identifier",
"definition": "External identifier - FHIR will generate its own internal identifiers (probably URLs) which do not need to be explicitly managed by the resource. The identifier here is one that would be used by another non-FHIR system - for example an automated medication pump would provide a record each time it operated; an administration while the patient was off the ward might be made with a different system and entered after the event. Particularly important if these records have to be updated.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…identifer"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MedicationStatement.basedOn",
"path": "MedicationStatement.basedOn",
"short": "Fulfils plan, proposal or order",
"definition": "A plan, proposal or order that is fulfilled in whole or in part by this event.",
"requirements": "Allows tracing of authorization for the event and tracking whether proposals/recommendations were acted upon.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…basedOn"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target[classCode=SBADM or PROC or PCPR or OBS, moodCode=RQO orPLAN or PRP]"
}
]
},
{
"id": "MedicationStatement.partOf",
"path": "MedicationStatement.partOf",
"short": "Part of referenced event",
"definition": "A larger event of which this particular event is a component or step.",
"requirements": "This should not be used when indicating which resource a MedicationStatement has been derived from. If that is the use case, then MedicationStatement.derivedFrom should be used.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationAdministration"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationDispense"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationStatement"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Procedure"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…part of"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP]/target[classCode=SPLY or SBADM or PROC or OBS,moodCode=EVN]"
}
]
},
{
"id": "MedicationStatement.context",
"path": "MedicationStatement.context",
"short": "Encounter / Episode associated with MedicationStatement",
"definition": "The encounter or episode of care that establishes the context for this MedicationStatement.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…context"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN, code=\"type of encounter or episode\"]"
}
]
},
{
"id": "MedicationStatement.status",
"path": "MedicationStatement.status",
"short": "active | completed | entered-in-error | intended | stopped | on-hold",
"definition": "A code representing the patient or other source's judgment about the state of the medication used that this statement is about. Generally this will be active or completed.",
"comment": "MedicationStatement is a statement at a point in time. The status is only representative at the point when it was asserted. The value set for MedicationStatement.status contains codes that assert the status of the use of the medication by the patient (for example, stopped or on hold) as well as codes that assert the status of the medication statement itself (for example, entered in error).\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationStatementStatus"
}
],
"strength": "required",
"description": "A coded concept indicating the current status of a MedicationStatement.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-statement-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…status"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MedicationStatement.category",
"path": "MedicationStatement.category",
"short": "Type of medication usage",
"definition": "Indicates where type of medication statement and where the medication is expected to be consumed or administered.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationStatementCategory"
}
],
"strength": "preferred",
"description": "A coded concept identifying where the medication included in the medicationstatement is expected to be consumed or administered",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-statement-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=OBS, moodCode=EVN, code=\"type of medication usage\"].value"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "MedicationStatement.medication[x]",
"path": "MedicationStatement.medication[x]",
"short": "What medication was taken",
"definition": "Identifies the medication being administered. This is either a link to a resource representing the details of the medication or a simple attribute carrying a code that identifies the medication from a known list of medications.",
"comment": "If only a code is specified, then it needs to be a code for a specific product. If more information is required, then the use of the medication resource is recommended. For example if you require form or lot number, then you must reference the Medication resource. .",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationCode"
}
],
"strength": "example",
"description": "A coded concept identifying the substance or product being taken.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…code"
},
{
"identity": "rim",
"map": ".participation[typeCode=CSM].role[classCode=ADMM or MANU]"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "MedicationStatement.effective[x]",
"path": "MedicationStatement.effective[x]",
"short": "The date/time or interval when the medication was taken",
"definition": "The interval of time during which it is being asserted that the patient was taking the medication (or was not taking, when the wasNotGiven element is true).",
"comment": "This attribute reflects the period over which the patient consumed the medication and is expected to be populated on the majority of Medication Statements. If the medication is still being taken at the time the statement is recorded, the \"end\" date will be omitted.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…occurrence[x]"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "MedicationStatement.dateAsserted",
"path": "MedicationStatement.dateAsserted",
"short": "When the statement was asserted?",
"definition": "The date when the medication statement was asserted by the information source.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "MedicationStatement.informationSource",
"path": "MedicationStatement.informationSource",
"short": "Person or organization that provided the information about the taking of this medication",
"definition": "The person or organization that provided the information about the taking of this medication. Note: Use derivedFrom when a MedicationStatement is derived from other resources, e.g Claim or MedicationRequest.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=INF].role[classCode=PAT, or codes for Practioner or Related Person (if PAT is the informer, then syntax for self-reported =true)"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "MedicationStatement.subject",
"path": "MedicationStatement.subject",
"short": "Who is/was taking the medication",
"definition": "The person, animal or group who is/was taking the medication.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…subject"
},
{
"identity": "v2",
"map": "PID-3-Patient ID List"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role[classCode=PAT]"
},
{
"identity": "w5",
"map": "who"
}
]
},
{
"id": "MedicationStatement.derivedFrom",
"path": "MedicationStatement.derivedFrom",
"short": "Additional supporting information",
"definition": "Allows linking the MedicationStatement to the underlying MedicationRequest, or to other information that supports or is used to derive the MedicationStatement.",
"comment": "Likely references would be to MedicationRequest, MedicationDispense, Claim, Observation or QuestionnaireAnswers. The most common use cases for deriving a MedicationStatement comes from creating a MedicationStatement from a MedicationRequest or from a lab observation or a claim. it should be noted that the amount of information that is available varies from the type resource that you derive the MedicationStatement from.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=SPRT]/target[classCode=ACT,moodCode=EVN]"
}
]
},
{
"id": "MedicationStatement.taken",
"path": "MedicationStatement.taken",
"short": "y | n | unk | na",
"definition": "Indicator of the certainty of whether the medication was taken by the patient.",
"comment": "This element is labeled as a modifier because it indicates that the medication was not taken.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationStatementTaken"
}
],
"strength": "required",
"description": "A coded concept identifying level of certainty if patient has taken or has not taken the medication",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-statement-taken"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…notDone"
},
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "MedicationStatement.reasonNotTaken",
"path": "MedicationStatement.reasonNotTaken",
"short": "True if asserting medication was not given",
"definition": "A code indicating why the medication was not taken.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"mst-1"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationStatementNotTakenReason"
}
],
"strength": "example",
"description": "A coded concept indicating the reason why the medication was not taken",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/reason-medication-not-taken-codes"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON]/target[classCode=OBS,moodCode=EVN, code=\"reason not taken\"].value"
}
]
},
{
"id": "MedicationStatement.reasonCode",
"path": "MedicationStatement.reasonCode",
"short": "Reason for why the medication is being/was taken",
"definition": "A reason for why the medication is being/was taken.",
"comment": "This could be a diagnosis code. If a full condition record exists or additional detail is needed, use reasonForUseReference.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationReason"
}
],
"strength": "example",
"description": "A coded concept identifying why the medication is being taken.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/condition-code"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…reasoneCodeableConcept"
},
{
"identity": "rim",
"map": ".reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MedicationStatement.reasonReference",
"path": "MedicationStatement.reasonReference",
"short": "Condition or observation that supports why the medication is being/was taken",
"definition": "Condition or observation that supports why the medication is being/was taken.",
"comment": "This is a reference to a condition that is the reason why the medication is being/was taken. If only a code exists, use reasonForUseCode.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…reasonReference"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON]/target[classCode=OBS,moodCode=EVN, code=\"reason for use\"].value"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MedicationStatement.note",
"path": "MedicationStatement.note",
"short": "Further information about the statement",
"definition": "Provides extra information about the medication statement that is not conveyed by the other attributes.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…note"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=OBS,moodCode=EVN,code=\"annotation\"].value"
}
]
},
{
"id": "MedicationStatement.dosage",
"path": "MedicationStatement.dosage",
"short": "Details of how medication is/was taken or should be taken",
"definition": "Indicates how the medication is/was or should be taken by the patient.",
"comment": "The dates included in the dosage on a Medication Statement reflect the dates for a given dose. For example, \"from November 1, 2016 to November 3, 2016, take one tablet daily and from November 4, 2016 to November 7, 2016, take two tablets daily.\" It is expected that this specificity may only be populated where the patient brings in their labeled container or where the Medication Statement is derived from a MedicationRequest.",
"min": 0,
"max": "*",
"type": [
{
"code": "Dosage"
}
],
"mapping": [
{
"identity": "rim",
"map": "refer dosageInstruction mapping"
}
]
}
]
},
"differential": {
"element": [
{
"id": "MedicationStatement",
"path": "MedicationStatement",
"short": "Record of medication being taken by a patient",
"definition": "A record of a medication that is being consumed by a patient. A MedicationStatement may indicate that the patient may be taking the medication now, or has taken the medication in the past or will be taking the medication in the future. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay. The medication information may come from sources such as the patient's memory, from a prescription bottle, or from a list of medications the patient, clinician or other party maintains \r\rThe primary difference between a medication statement and a medication administration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication. A medication statement is often, if not always, less specific. There is no required date/time when the medication was administered, in fact we only know that a source has reported the patient is taking this medication, where details such as time, quantity, or rate or even medication product may be incomplete or missing or less precise. As stated earlier, the medication statement information may come from the patient's memory, from a prescription bottle or from a list of medications the patient, clinician or other party maintains. Medication administration is more formal and is not missing detailed information.",
"comment": "When interpreting a medicationStatement, the value of the status and NotTaken needed to be considered:\rMedicationStatement.status + MedicationStatement.wasNotTaken\rStatus=Active + NotTaken=T = Not currently taking\rStatus=Completed + NotTaken=T = Not taken in the past\rStatus=Intended + NotTaken=T = No intention of taking\rStatus=Active + NotTaken=F = Taking, but not as prescribed\rStatus=Active + NotTaken=F = Taking\rStatus=Intended +NotTaken= F = Will be taking (not started)\rStatus=Completed + NotTaken=F = Taken in past\rStatus=In Error + NotTaken=N/A = In Error.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "mst-1",
"severity": "error",
"human": "Reason not taken is only permitted if Taken is No",
"expression": "reasonNotTaken.exists().not() or (taken = 'n')",
"xpath": "not(exists(f:reasonNotTaken)) or f:taken/@value='n'"
}
],
"mapping": [
{
"identity": "workflow",
"map": "..Event"
},
{
"identity": "rim",
"map": "SubstanceAdministration"
},
{
"identity": "w5",
"map": "clinical.medication"
}
]
},
{
"id": "MedicationStatement.identifier",
"path": "MedicationStatement.identifier",
"short": "External identifier",
"definition": "External identifier - FHIR will generate its own internal identifiers (probably URLs) which do not need to be explicitly managed by the resource. The identifier here is one that would be used by another non-FHIR system - for example an automated medication pump would provide a record each time it operated; an administration while the patient was off the ward might be made with a different system and entered after the event. Particularly important if these records have to be updated.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…identifer"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MedicationStatement.basedOn",
"path": "MedicationStatement.basedOn",
"short": "Fulfils plan, proposal or order",
"definition": "A plan, proposal or order that is fulfilled in whole or in part by this event.",
"requirements": "Allows tracing of authorization for the event and tracking whether proposals/recommendations were acted upon.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…basedOn"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target[classCode=SBADM or PROC or PCPR or OBS, moodCode=RQO orPLAN or PRP]"
}
]
},
{
"id": "MedicationStatement.partOf",
"path": "MedicationStatement.partOf",
"short": "Part of referenced event",
"definition": "A larger event of which this particular event is a component or step.",
"requirements": "This should not be used when indicating which resource a MedicationStatement has been derived from. If that is the use case, then MedicationStatement.derivedFrom should be used.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationAdministration"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationDispense"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationStatement"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Procedure"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…part of"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP]/target[classCode=SPLY or SBADM or PROC or OBS,moodCode=EVN]"
}
]
},
{
"id": "MedicationStatement.context",
"path": "MedicationStatement.context",
"short": "Encounter / Episode associated with MedicationStatement",
"definition": "The encounter or episode of care that establishes the context for this MedicationStatement.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…context"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN, code=\"type of encounter or episode\"]"
}
]
},
{
"id": "MedicationStatement.status",
"path": "MedicationStatement.status",
"short": "active | completed | entered-in-error | intended | stopped | on-hold",
"definition": "A code representing the patient or other source's judgment about the state of the medication used that this statement is about. Generally this will be active or completed.",
"comment": "MedicationStatement is a statement at a point in time. The status is only representative at the point when it was asserted. The value set for MedicationStatement.status contains codes that assert the status of the use of the medication by the patient (for example, stopped or on hold) as well as codes that assert the status of the medication statement itself (for example, entered in error).\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationStatementStatus"
}
],
"strength": "required",
"description": "A coded concept indicating the current status of a MedicationStatement.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-statement-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…status"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MedicationStatement.category",
"path": "MedicationStatement.category",
"short": "Type of medication usage",
"definition": "Indicates where type of medication statement and where the medication is expected to be consumed or administered.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationStatementCategory"
}
],
"strength": "preferred",
"description": "A coded concept identifying where the medication included in the medicationstatement is expected to be consumed or administered",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-statement-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=OBS, moodCode=EVN, code=\"type of medication usage\"].value"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "MedicationStatement.medication[x]",
"path": "MedicationStatement.medication[x]",
"short": "What medication was taken",
"definition": "Identifies the medication being administered. This is either a link to a resource representing the details of the medication or a simple attribute carrying a code that identifies the medication from a known list of medications.",
"comment": "If only a code is specified, then it needs to be a code for a specific product. If more information is required, then the use of the medication resource is recommended. For example if you require form or lot number, then you must reference the Medication resource. .",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationCode"
}
],
"strength": "example",
"description": "A coded concept identifying the substance or product being taken.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…code"
},
{
"identity": "rim",
"map": ".participation[typeCode=CSM].role[classCode=ADMM or MANU]"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "MedicationStatement.effective[x]",
"path": "MedicationStatement.effective[x]",
"short": "The date/time or interval when the medication was taken",
"definition": "The interval of time during which it is being asserted that the patient was taking the medication (or was not taking, when the wasNotGiven element is true).",
"comment": "This attribute reflects the period over which the patient consumed the medication and is expected to be populated on the majority of Medication Statements. If the medication is still being taken at the time the statement is recorded, the \"end\" date will be omitted.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…occurrence[x]"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "MedicationStatement.dateAsserted",
"path": "MedicationStatement.dateAsserted",
"short": "When the statement was asserted?",
"definition": "The date when the medication statement was asserted by the information source.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "MedicationStatement.informationSource",
"path": "MedicationStatement.informationSource",
"short": "Person or organization that provided the information about the taking of this medication",
"definition": "The person or organization that provided the information about the taking of this medication. Note: Use derivedFrom when a MedicationStatement is derived from other resources, e.g Claim or MedicationRequest.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=INF].role[classCode=PAT, or codes for Practioner or Related Person (if PAT is the informer, then syntax for self-reported =true)"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "MedicationStatement.subject",
"path": "MedicationStatement.subject",
"short": "Who is/was taking the medication",
"definition": "The person, animal or group who is/was taking the medication.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "…subject"
},
{
"identity": "v2",
"map": "PID-3-Patient ID List"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role[classCode=PAT]"
},
{
"identity": "w5",
"map": "who"
}
]
},
{
"id": "MedicationStatement.derivedFrom",
"path": "MedicationStatement.derivedFrom",
"short": "Additional supporting information",
"definition": "Allows linking the MedicationStatement to the underlying MedicationRequest, or to other information that supports or is used to derive the MedicationStatement.",
"comment": "Likely references would be to MedicationRequest, MedicationDispense, Claim, Observation or QuestionnaireAnswers. The most common use cases for deriving a MedicationStatement comes from creating a MedicationStatement from a MedicationRequest or from a lab observation or a claim. it should be noted that the amount of information that is available varies from the type resource that you derive the MedicationStatement from.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=SPRT]/target[classCode=ACT,moodCode=EVN]"
}
]
},
{
"id": "MedicationStatement.taken",
"path": "MedicationStatement.taken",
"short": "y | n | unk | na",
"definition": "Indicator of the certainty of whether the medication was taken by the patient.",
"comment": "This element is labeled as a modifier because it indicates that the medication was not taken.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationStatementTaken"
}
],
"strength": "required",
"description": "A coded concept identifying level of certainty if patient has taken or has not taken the medication",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-statement-taken"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…notDone"
},
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "MedicationStatement.reasonNotTaken",
"path": "MedicationStatement.reasonNotTaken",
"short": "True if asserting medication was not given",
"definition": "A code indicating why the medication was not taken.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"mst-1"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationStatementNotTakenReason"
}
],
"strength": "example",
"description": "A coded concept indicating the reason why the medication was not taken",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/reason-medication-not-taken-codes"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON]/target[classCode=OBS,moodCode=EVN, code=\"reason not taken\"].value"
}
]
},
{
"id": "MedicationStatement.reasonCode",
"path": "MedicationStatement.reasonCode",
"short": "Reason for why the medication is being/was taken",
"definition": "A reason for why the medication is being/was taken.",
"comment": "This could be a diagnosis code. If a full condition record exists or additional detail is needed, use reasonForUseReference.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MedicationReason"
}
],
"strength": "example",
"description": "A coded concept identifying why the medication is being taken.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/condition-code"
}
},
"mapping": [
{
"identity": "workflow",
"map": "…reasoneCodeableConcept"
},
{
"identity": "rim",
"map": ".reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MedicationStatement.reasonReference",
"path": "MedicationStatement.reasonReference",
"short": "Condition or observation that supports why the medication is being/was taken",
"definition": "Condition or observation that supports why the medication is being/was taken.",
"comment": "This is a reference to a condition that is the reason why the medication is being/was taken. If only a code exists, use reasonForUseCode.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…reasonReference"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON]/target[classCode=OBS,moodCode=EVN, code=\"reason for use\"].value"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MedicationStatement.note",
"path": "MedicationStatement.note",
"short": "Further information about the statement",
"definition": "Provides extra information about the medication statement that is not conveyed by the other attributes.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "…note"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ]/source[classCode=OBS,moodCode=EVN,code=\"annotation\"].value"
}
]
},
{
"id": "MedicationStatement.dosage",
"path": "MedicationStatement.dosage",
"short": "Details of how medication is/was taken or should be taken",
"definition": "Indicates how the medication is/was or should be taken by the patient.",
"comment": "The dates included in the dosage on a Medication Statement reflect the dates for a given dose. For example, \"from November 1, 2016 to November 3, 2016, take one tablet daily and from November 4, 2016 to November 7, 2016, take two tablets daily.\" It is expected that this specificity may only be populated where the patient brings in their labeled container or where the Medication Statement is derived from a MedicationRequest.",
"min": 0,
"max": "*",
"type": [
{
"code": "Dosage"
}
],
"mapping": [
{
"identity": "rim",
"map": "refer dosageInstruction mapping"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/MessageDefinition",
"resource": {
"resourceType": "StructureDefinition",
"id": "MessageDefinition",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints MessageDefinition DomainResource A resource that defines a type of message that can be exchanged between systems
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension url Σ 0..1 uri Logical URI to reference this message definition (globally unique) identifier Σ 0..1 Identifier Additional identifier for the message definition version Σ 0..1 string Business version of the message definition name Σ 0..1 string Name for this message definition (computer friendly) title Σ 0..1 string Name for this message definition (human friendly) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) experimental ?!Σ 0..1 boolean For testing purposes, not real usage date Σ 1..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) contact Σ 0..* ContactDetail Contact details for the publisher
description Σ 0..1 markdown Natural language description of the message definition useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for message definition (if applicable)
Jurisdiction ValueSet (Extensible)
purpose Σ 0..1 markdown Why this message definition is defined copyright 0..1 markdown Use and/or publishing restrictions base Σ 0..1 Reference(MessageDefinition) Definition this one is based on parent Σ 0..* Reference(ActivityDefinition | PlanDefinition) Protocol/workflow this is part of
replaces Σ 0..* Reference(MessageDefinition) Takes the place of
event Σ 1..1 Coding Event type
MessageEvent (Example) category Σ 0..1 code Consequence | Currency | Notification
MessageSignificanceCategory (Required) focus ΣI 0..* BackboneElement Resource(s) that are the subject of the event
+ Max must be postive int or *
code Σ 1..1 code Type of resource
ResourceType (Required) profile 0..1 Reference(StructureDefinition) Profile that must be adhered to by focus min 0..1 unsignedInt Minimum number of focuses of this type max I 0..1 string Maximum number of focuses of this type responseRequired 0..1 boolean Is a response required? allowedResponse 0..* BackboneElement Responses to this message
message 1..1 Reference(MessageDefinition) Reference to allowed message definition response situation 0..1 markdown When should this response be used
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 0
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "inm"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/MessageDefinition",
"name": "MessageDefinition",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Infrastructure And Messaging)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/special/committees/inm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for MessageDefinition Resource",
"purpose": "Allows messages to be defined once and re-used across systems.",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "objimpl",
"uri": "http://hl7.org/fhir/object-implementation",
"name": "Object Implementation Information"
}
],
"kind": "resource",
"abstract": false,
"type": "MessageDefinition",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"_baseDefinition": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-codegen-super",
"valueString": "MetadataResource"
}
]
},
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "MessageDefinition",
"path": "MessageDefinition",
"short": "A resource that defines a type of message that can be exchanged between systems",
"definition": "Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted.",
"comment": "This would be a MIF-level artifact.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "infrastructure.exchange"
}
]
},
{
"id": "MessageDefinition.id",
"path": "MessageDefinition.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.meta",
"path": "MessageDefinition.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.implicitRules",
"path": "MessageDefinition.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "MessageDefinition.language",
"path": "MessageDefinition.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "MessageDefinition.text",
"path": "MessageDefinition.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "MessageDefinition.contained",
"path": "MessageDefinition.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MessageDefinition.extension",
"path": "MessageDefinition.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MessageDefinition.modifierExtension",
"path": "MessageDefinition.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MessageDefinition.url",
"path": "MessageDefinition.url",
"short": "Logical URI to reference this message definition (globally unique)",
"definition": "An absolute URI that is used to identify this message definition when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this message definition is (or will be) published. The URL SHOULD include the major version of the message definition. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the message definition to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MessageDefinition.identifier",
"path": "MessageDefinition.identifier",
"short": "Additional identifier for the message definition",
"definition": "A formal identifier that is used to identify this message definition when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this message definition outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MessageDefinition.version",
"path": "MessageDefinition.version",
"short": "Business version of the message definition",
"definition": "The identifier that is used to identify this version of the message definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the message definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different message definition instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the message definition with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "MessageDefinition.name",
"path": "MessageDefinition.name",
"short": "Name for this message definition (computer friendly)",
"definition": "A natural language name identifying the message definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.title",
"path": "MessageDefinition.title",
"short": "Name for this message definition (human friendly)",
"definition": "A short, descriptive, user-friendly title for the message definition.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.status",
"path": "MessageDefinition.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this message definition. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of message definitions that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired message definition without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MessageDefinition.experimental",
"path": "MessageDefinition.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this message definition is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of message definition that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental message definition in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level message definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "MessageDefinition.date",
"path": "MessageDefinition.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the message definition was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the message definition changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the message definition. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 1,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "MessageDefinition.publisher",
"path": "MessageDefinition.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the message definition.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the message definition is the organization or individual primarily responsible for the maintenance and upkeep of the message definition. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the message definition. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the message definition. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "MessageDefinition.contact",
"path": "MessageDefinition.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.description",
"path": "MessageDefinition.description",
"short": "Natural language description of the message definition",
"definition": "A free text natural language description of the message definition from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the message definition was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the message definition as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.useContext",
"path": "MessageDefinition.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate message definition instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.jurisdiction",
"path": "MessageDefinition.jurisdiction",
"short": "Intended jurisdiction for message definition (if applicable)",
"definition": "A legal or geographic region in which the message definition is intended to be used.",
"comment": "It may be possible for the message definition to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "MessageDefinition.purpose",
"path": "MessageDefinition.purpose",
"short": "Why this message definition is defined",
"definition": "Explaination of why this message definition is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the message definition Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this message definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MessageDefinition.copyright",
"path": "MessageDefinition.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the message definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the message definition.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the message definition and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "MessageDefinition.base",
"path": "MessageDefinition.base",
"short": "Definition this one is based on",
"definition": "The MessageDefinition that is the basis for the contents of this resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MessageDefinition"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.parent",
"path": "MessageDefinition.parent",
"short": "Protocol/workflow this is part of",
"definition": "Identifies a protocol or workflow that this MessageDefinition represents a step in.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.replaces",
"path": "MessageDefinition.replaces",
"short": "Takes the place of",
"definition": "A MessageDefinition that is superseded by this definition.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MessageDefinition"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.event",
"path": "MessageDefinition.event",
"short": "Event type",
"definition": "A coded identifier of a supported messaging event.",
"min": 1,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MessageEvent"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "example",
"description": "One of the message events defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/message-events"
}
}
},
{
"id": "MessageDefinition.category",
"path": "MessageDefinition.category",
"short": "Consequence | Currency | Notification",
"definition": "The impact of the content of the message.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MessageSignificanceCategory"
}
],
"strength": "required",
"description": "The impact of the content of a message.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/message-significance-category"
}
}
},
{
"id": "MessageDefinition.focus",
"path": "MessageDefinition.focus",
"short": "Resource(s) that are the subject of the event",
"definition": "Identifies the resource (or resources) that are being addressed by the event. For example, the Encounter for an admit message or two Account records for a merge.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "md-1",
"severity": "error",
"human": "Max must be postive int or *",
"expression": "max='*' or (max.toInteger() > 0)",
"xpath": "f:max/@value='*' or number(f:max/@value) > 0"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.focus.id",
"path": "MessageDefinition.focus.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MessageDefinition.focus.extension",
"path": "MessageDefinition.focus.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MessageDefinition.focus.modifierExtension",
"path": "MessageDefinition.focus.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MessageDefinition.focus.code",
"path": "MessageDefinition.focus.code",
"short": "Type of resource",
"definition": "The kind of resource that must be the focus for this message.",
"comment": "Multiple focuses addressing different resources may occasionally occur. E.g. to link or unlink a resource from a particular account or encounter, etc.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResourceType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "One of the resource types defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/resource-types"
}
}
},
{
"id": "MessageDefinition.focus.profile",
"path": "MessageDefinition.focus.profile",
"short": "Profile that must be adhered to by focus",
"definition": "A profile that reflects constraints for the focal resource (and potentially for related resources).",
"comment": "This should be present for most message definitions. However, if the message focus is only a single resource and there is no need to include referenced resources or otherwise enforce the presence of particular elements, it can be omitted.",
"requirements": "This profile allows setting boundaries for what content must appear within the message bundle vs. outside based on the declared aggregation constraints on referenced resources on this and related profiles.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/StructureDefinition"
}
]
},
{
"id": "MessageDefinition.focus.min",
"path": "MessageDefinition.focus.min",
"short": "Minimum number of focuses of this type",
"definition": "Identifies the minimum number of resources of this type that must be pointed to by a message in order for it to be valid against this MessageDefinition.",
"min": 0,
"max": "1",
"type": [
{
"code": "unsignedInt"
}
],
"defaultValueUnsignedInt": 0
},
{
"id": "MessageDefinition.focus.max",
"path": "MessageDefinition.focus.max",
"short": "Maximum number of focuses of this type",
"definition": "Identifies the maximum number of resources of this type that must be pointed to by a message in order for it to be valid against this MessageDefinition.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"md-1"
]
},
{
"id": "MessageDefinition.responseRequired",
"path": "MessageDefinition.responseRequired",
"short": "Is a response required?",
"definition": "Indicates whether a response is required for this message.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "MessageDefinition.allowedResponse",
"path": "MessageDefinition.allowedResponse",
"short": "Responses to this message",
"definition": "Indicates what types of messages may be sent as an application-level response to this message.",
"comment": "This indicates an application level response to \"close\" a transaction implicit in a particular request message. To define a complete workflow scenario, look to the [[PlanDefinition]] resource which allows the definition of complex orchestrations, conditionality, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "MessageDefinition.allowedResponse.id",
"path": "MessageDefinition.allowedResponse.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MessageDefinition.allowedResponse.extension",
"path": "MessageDefinition.allowedResponse.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MessageDefinition.allowedResponse.modifierExtension",
"path": "MessageDefinition.allowedResponse.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MessageDefinition.allowedResponse.message",
"path": "MessageDefinition.allowedResponse.message",
"short": "Reference to allowed message definition response",
"definition": "A reference to the message definition that must be adhered to by this supported response.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MessageDefinition"
}
]
},
{
"id": "MessageDefinition.allowedResponse.situation",
"path": "MessageDefinition.allowedResponse.situation",
"short": "When should this response be used",
"definition": "Provides a description of the circumstances in which this response should be used (as opposed to one of the alternative responses).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
}
]
},
"differential": {
"element": [
{
"id": "MessageDefinition",
"path": "MessageDefinition",
"short": "A resource that defines a type of message that can be exchanged between systems",
"definition": "Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted.",
"comment": "This would be a MIF-level artifact.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "infrastructure.exchange"
}
]
},
{
"id": "MessageDefinition.url",
"path": "MessageDefinition.url",
"short": "Logical URI to reference this message definition (globally unique)",
"definition": "An absolute URI that is used to identify this message definition when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this message definition is (or will be) published. The URL SHOULD include the major version of the message definition. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the message definition to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MessageDefinition.identifier",
"path": "MessageDefinition.identifier",
"short": "Additional identifier for the message definition",
"definition": "A formal identifier that is used to identify this message definition when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this message definition outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MessageDefinition.version",
"path": "MessageDefinition.version",
"short": "Business version of the message definition",
"definition": "The identifier that is used to identify this version of the message definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the message definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different message definition instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the message definition with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "MessageDefinition.name",
"path": "MessageDefinition.name",
"short": "Name for this message definition (computer friendly)",
"definition": "A natural language name identifying the message definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.title",
"path": "MessageDefinition.title",
"short": "Name for this message definition (human friendly)",
"definition": "A short, descriptive, user-friendly title for the message definition.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.status",
"path": "MessageDefinition.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this message definition. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of message definitions that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired message definition without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MessageDefinition.experimental",
"path": "MessageDefinition.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this message definition is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of message definition that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental message definition in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level message definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "MessageDefinition.date",
"path": "MessageDefinition.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the message definition was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the message definition changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the message definition. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 1,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "MessageDefinition.publisher",
"path": "MessageDefinition.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the message definition.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the message definition is the organization or individual primarily responsible for the maintenance and upkeep of the message definition. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the message definition. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the message definition. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "MessageDefinition.contact",
"path": "MessageDefinition.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.description",
"path": "MessageDefinition.description",
"short": "Natural language description of the message definition",
"definition": "A free text natural language description of the message definition from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the message definition was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the message definition as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.useContext",
"path": "MessageDefinition.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate message definition instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.jurisdiction",
"path": "MessageDefinition.jurisdiction",
"short": "Intended jurisdiction for message definition (if applicable)",
"definition": "A legal or geographic region in which the message definition is intended to be used.",
"comment": "It may be possible for the message definition to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "MessageDefinition.purpose",
"path": "MessageDefinition.purpose",
"short": "Why this message definition is defined",
"definition": "Explaination of why this message definition is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the message definition Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this message definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MessageDefinition.copyright",
"path": "MessageDefinition.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the message definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the message definition.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the message definition and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "MessageDefinition.base",
"path": "MessageDefinition.base",
"short": "Definition this one is based on",
"definition": "The MessageDefinition that is the basis for the contents of this resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MessageDefinition"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.parent",
"path": "MessageDefinition.parent",
"short": "Protocol/workflow this is part of",
"definition": "Identifies a protocol or workflow that this MessageDefinition represents a step in.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.replaces",
"path": "MessageDefinition.replaces",
"short": "Takes the place of",
"definition": "A MessageDefinition that is superseded by this definition.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MessageDefinition"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.event",
"path": "MessageDefinition.event",
"short": "Event type",
"definition": "A coded identifier of a supported messaging event.",
"min": 1,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MessageEvent"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "example",
"description": "One of the message events defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/message-events"
}
}
},
{
"id": "MessageDefinition.category",
"path": "MessageDefinition.category",
"short": "Consequence | Currency | Notification",
"definition": "The impact of the content of the message.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MessageSignificanceCategory"
}
],
"strength": "required",
"description": "The impact of the content of a message.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/message-significance-category"
}
}
},
{
"id": "MessageDefinition.focus",
"path": "MessageDefinition.focus",
"short": "Resource(s) that are the subject of the event",
"definition": "Identifies the resource (or resources) that are being addressed by the event. For example, the Encounter for an admit message or two Account records for a merge.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "md-1",
"severity": "error",
"human": "Max must be postive int or *",
"expression": "max='*' or (max.toInteger() > 0)",
"xpath": "f:max/@value='*' or number(f:max/@value) > 0"
}
],
"isSummary": true
},
{
"id": "MessageDefinition.focus.code",
"path": "MessageDefinition.focus.code",
"short": "Type of resource",
"definition": "The kind of resource that must be the focus for this message.",
"comment": "Multiple focuses addressing different resources may occasionally occur. E.g. to link or unlink a resource from a particular account or encounter, etc.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResourceType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "One of the resource types defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/resource-types"
}
}
},
{
"id": "MessageDefinition.focus.profile",
"path": "MessageDefinition.focus.profile",
"short": "Profile that must be adhered to by focus",
"definition": "A profile that reflects constraints for the focal resource (and potentially for related resources).",
"comment": "This should be present for most message definitions. However, if the message focus is only a single resource and there is no need to include referenced resources or otherwise enforce the presence of particular elements, it can be omitted.",
"requirements": "This profile allows setting boundaries for what content must appear within the message bundle vs. outside based on the declared aggregation constraints on referenced resources on this and related profiles.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/StructureDefinition"
}
]
},
{
"id": "MessageDefinition.focus.min",
"path": "MessageDefinition.focus.min",
"short": "Minimum number of focuses of this type",
"definition": "Identifies the minimum number of resources of this type that must be pointed to by a message in order for it to be valid against this MessageDefinition.",
"min": 0,
"max": "1",
"type": [
{
"code": "unsignedInt"
}
],
"defaultValueUnsignedInt": 0
},
{
"id": "MessageDefinition.focus.max",
"path": "MessageDefinition.focus.max",
"short": "Maximum number of focuses of this type",
"definition": "Identifies the maximum number of resources of this type that must be pointed to by a message in order for it to be valid against this MessageDefinition.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"md-1"
]
},
{
"id": "MessageDefinition.responseRequired",
"path": "MessageDefinition.responseRequired",
"short": "Is a response required?",
"definition": "Indicates whether a response is required for this message.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "MessageDefinition.allowedResponse",
"path": "MessageDefinition.allowedResponse",
"short": "Responses to this message",
"definition": "Indicates what types of messages may be sent as an application-level response to this message.",
"comment": "This indicates an application level response to \"close\" a transaction implicit in a particular request message. To define a complete workflow scenario, look to the [[PlanDefinition]] resource which allows the definition of complex orchestrations, conditionality, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "MessageDefinition.allowedResponse.message",
"path": "MessageDefinition.allowedResponse.message",
"short": "Reference to allowed message definition response",
"definition": "A reference to the message definition that must be adhered to by this supported response.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MessageDefinition"
}
]
},
{
"id": "MessageDefinition.allowedResponse.situation",
"path": "MessageDefinition.allowedResponse.situation",
"short": "When should this response be used",
"definition": "Provides a description of the circumstances in which this response should be used (as opposed to one of the alternative responses).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/MessageHeader",
"resource": {
"resourceType": "StructureDefinition",
"id": "MessageHeader",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints MessageHeader Σ DomainResource A resource that describes a message that is exchanged between systems
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension event Σ 1..1 Coding Code for the event this message represents
MessageEvent (Example) destination Σ 0..* BackboneElement Message destination application(s)
name Σ 0..1 string Name of system target Σ 0..1 Reference(Device) Particular delivery destination within the destination endpoint Σ 1..1 uri Actual destination address or id receiver Σ 0..1 Reference(Practitioner | Organization) Intended "real-world" recipient for the data sender Σ 0..1 Reference(Practitioner | Organization) Real world sender of the message timestamp Σ 1..1 instant Time that the message was sent enterer Σ 0..1 Reference(Practitioner) The source of the data entry author Σ 0..1 Reference(Practitioner) The source of the decision source Σ 1..1 BackboneElement Message source application name Σ 0..1 string Name of system software Σ 0..1 string Name of software running the system version Σ 0..1 string Version of software running contact Σ 0..1 ContactPoint Human contact for problems endpoint Σ 1..1 uri Actual message source address or id responsible Σ 0..1 Reference(Practitioner | Organization) Final responsibility for event reason Σ 0..1 CodeableConcept Cause of event
Example Message Reason Codes (Example) response Σ 0..1 BackboneElement If this is a reply to prior message identifier Σ 1..1 id Id of original message code Σ 1..1 code ok | transient-error | fatal-error
ResponseType (Required) details Σ 0..1 Reference(OperationOutcome) Specific list of hints/warnings/errors focus Σ 0..* Reference(Any) The actual content of the message
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "inm"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/MessageHeader",
"name": "MessageHeader",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Infrastructure And Messaging)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/special/committees/inm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for MessageHeader Resource",
"purpose": "Many implementations are not prepared to use REST and need a messaging based infrastructure.",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "MessageHeader",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "MessageHeader",
"path": "MessageHeader",
"short": "A resource that describes a message that is exchanged between systems",
"definition": "The header for a message exchange that is either requesting or responding to an action. The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "v2",
"map": "MSH / MSA / ERR"
},
{
"identity": "rim",
"map": "Message"
},
{
"identity": "w5",
"map": "infrastructure.exchange"
}
]
},
{
"id": "MessageHeader.id",
"path": "MessageHeader.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "MessageHeader.meta",
"path": "MessageHeader.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "MessageHeader.implicitRules",
"path": "MessageHeader.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "MessageHeader.language",
"path": "MessageHeader.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "MessageHeader.text",
"path": "MessageHeader.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "MessageHeader.contained",
"path": "MessageHeader.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MessageHeader.extension",
"path": "MessageHeader.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MessageHeader.modifierExtension",
"path": "MessageHeader.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MessageHeader.event",
"path": "MessageHeader.event",
"short": "Code for the event this message represents",
"definition": "Code that identifies the event this message represents and connects it with its definition. Events defined as part of the FHIR specification have the system value \"http://hl7.org/fhir/message-events\".",
"requirements": "Drives the behavior associated with this message.",
"min": 1,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MessageEvent"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "example",
"description": "One of the message events defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/message-events"
}
},
"mapping": [
{
"identity": "v2",
"map": "MSH-9.2"
},
{
"identity": "rim",
"map": "./payload[classCode=\"CACT\" and moodCode=\"EVN\" and isNormalAct()]/code[isNormalDatatype()]/code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "MessageHeader.destination",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "MessageDestination"
}
],
"path": "MessageHeader.destination",
"short": "Message destination application(s)",
"definition": "The destination application which the message is intended for.",
"comment": "There SHOULD be at least one destination, but in some circumstances, the source system is unaware of any particular destination system.",
"requirements": "Indicates where message is to be sent for routing purposes. Allows verification of \"am I the intended recipient\".",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "./communicationFunction[typeCode=\"RCV\"]"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MessageHeader.destination.id",
"path": "MessageHeader.destination.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MessageHeader.destination.extension",
"path": "MessageHeader.destination.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MessageHeader.destination.modifierExtension",
"path": "MessageHeader.destination.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MessageHeader.destination.name",
"path": "MessageHeader.destination.name",
"short": "Name of system",
"definition": "Human-readable name for the target system.",
"requirements": "May be used for routing of response and/or to support audit.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSH-5"
},
{
"identity": "rim",
"map": "unique(./entity[determinerCode=\"INST\" and (classCode=(\"DEV\", \"PSN\", \"ORG\"]/name[type='ST' and isNormalDatatype()])"
}
]
},
{
"id": "MessageHeader.destination.target",
"path": "MessageHeader.destination.target",
"short": "Particular delivery destination within the destination",
"definition": "Identifies the target end system in situations where the initial message transmission is to an intermediary system.",
"requirements": "Supports multi-hop routing.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "unique(./entity[determinerCode=\"INST\" and (classCode=(\"DEV\", \"PSN\", \"ORG\"]"
}
]
},
{
"id": "MessageHeader.destination.endpoint",
"path": "MessageHeader.destination.endpoint",
"short": "Actual destination address or id",
"definition": "Indicates where the message should be routed to.",
"comment": "The id may be a non-resolvable URI for systems that do not use standard network-based addresses.",
"requirements": "Identifies where to route the message.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSH-25 (or MSH-6)"
},
{
"identity": "rim",
"map": "./telecom"
}
]
},
{
"id": "MessageHeader.receiver",
"path": "MessageHeader.receiver",
"short": "Intended \"real-world\" recipient for the data",
"definition": "Allows data conveyed by a message to be addressed to a particular person or department when routing to a specific application isn't sufficient.",
"requirements": "Allows routing beyond just the application level.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRT-5:PRT-4='WAYR' / PRT-8:PRT-4='WAYR'"
},
{
"identity": "rim",
"map": "Not directly supported. Could be shared using attentionLine.value with an appropriate keyWordText"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MessageHeader.sender",
"path": "MessageHeader.sender",
"short": "Real world sender of the message",
"definition": "Identifies the sending system to allow the use of a trust relationship.",
"comment": "Use case is for where a (trusted) sending system is responsible for multiple organizations, and therefore cannot differentiate based on source endpoint / authentication alone.",
"requirements": "Allows routing beyond just the application level.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRT-5:PRT-4='WAYR' / PRT-8:PRT-4='WAYR'"
},
{
"identity": "rim",
"map": "Not directly supported. Could be shared using attentionLine.value with an appropriate keyWordText"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MessageHeader.timestamp",
"path": "MessageHeader.timestamp",
"short": "Time that the message was sent",
"definition": "The time that the message was sent.",
"requirements": "Allows limited detection of out-of-order and delayed transmission. Also supports audit.",
"min": 1,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSH-7"
},
{
"identity": "rim",
"map": "./creationTime[isNormalDatatype()]"
},
{
"identity": "w5",
"map": "when.init"
}
]
},
{
"id": "MessageHeader.enterer",
"path": "MessageHeader.enterer",
"short": "The source of the data entry",
"definition": "The person or device that performed the data entry leading to this message. When there is more than one candidate, pick the most proximal to the message. Can provide other enterers in extensions.",
"comment": "Usually only for the request, but can be used in a response.",
"requirements": "Need to know for audit/traceback requirements and possibly for authorization.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "EVN-5 / ORC-10 / PRT-5:PRT-4='EP' / ROL where ROL.3 is EP or ORC.10"
},
{
"identity": "rim",
"map": "unique(./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/participation[typeCode=\"ENT\" and isNormalParticipation]/role[classCode=\"ASSIGNED\" and isNormalRole()]/player[isNormalEntity() and classCode=(\"DEV\", \"PSN\") and determinerCode=\"INST\"])"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "MessageHeader.author",
"path": "MessageHeader.author",
"short": "The source of the decision",
"definition": "The logical author of the message - the person or device that decided the described event should happen. When there is more than one candidate, pick the most proximal to the MessageHeader. Can provide other authors in extensions.",
"comment": "Usually only for the request, but can be used in a response.",
"requirements": "Need to know for audit/traceback requirements and possibly for authorization.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ORC-19 / PRT-5:PRT-4='AUT' / ROL where ROL.3 is IP or ORC.12"
},
{
"identity": "rim",
"map": "unique(./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/participation[isHighest(priorityCode) and typeCode=\"AUT\" and isNormalParticipation]/role[classCode=\"ASSIGNED\" and isNormalRole()]/player[isNormalEntity() and classCode=(\"DEV\", \"PSN\") and determinerCode=\"INST\"])"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "MessageHeader.source",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "MessageSource"
}
],
"path": "MessageHeader.source",
"short": "Message source application",
"definition": "The source application from which this message originated.",
"requirements": "Allows replies, supports audit.",
"min": 1,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "unique(./communicationFunction[typeCode=\"SND\"])"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "MessageHeader.source.id",
"path": "MessageHeader.source.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MessageHeader.source.extension",
"path": "MessageHeader.source.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MessageHeader.source.modifierExtension",
"path": "MessageHeader.source.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MessageHeader.source.name",
"path": "MessageHeader.source.name",
"short": "Name of system",
"definition": "Human-readable name for the source system.",
"requirements": "May be used to support audit.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSH-3"
},
{
"identity": "rim",
"map": "unique(./entity[determinerCode=\"INST\" and classCode=\"DEV\"]/name[type='ST' and isNormalDatatype()])"
}
]
},
{
"id": "MessageHeader.source.software",
"path": "MessageHeader.source.software",
"short": "Name of software running the system",
"definition": "May include configuration or other information useful in debugging.",
"requirements": "Supports audit and possibly interface engine behavior.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SFT-3 ( +SFT-1)"
},
{
"identity": "rim",
"map": "unique(./entity[determinerCode=\"INST\" and classCode=\"DEV\"]/softwareName[isNormalDatatype()])"
}
]
},
{
"id": "MessageHeader.source.version",
"path": "MessageHeader.source.version",
"short": "Version of software running",
"definition": "Can convey versions of multiple systems in situations where a message passes through multiple hands.",
"requirements": "Supports audit and possibly interface engine behavior.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SFT-2"
},
{
"identity": "rim",
"map": "(Not supported)"
}
]
},
{
"id": "MessageHeader.source.contact",
"path": "MessageHeader.source.contact",
"short": "Human contact for problems",
"definition": "An e-mail, phone, website or other contact point to use to resolve issues with message communications.",
"requirements": "Allows escalation of technical issues.",
"min": 0,
"max": "1",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "(MSH-22?)"
},
{
"identity": "rim",
"map": "unique(./entity[determinerCode=\"INST\" and classCode=\"DEV\"]/scopesRole[normalRole() and classCode=\"CON\" and layer[classCode=\"PSN\"]/telecom[isNormalDatatype()])"
}
]
},
{
"id": "MessageHeader.source.endpoint",
"path": "MessageHeader.source.endpoint",
"short": "Actual message source address or id",
"definition": "Identifies the routing target to send acknowledgements to.",
"comment": "The id may be a non-resolvable URI for systems that do not use standard network-based addresses.",
"requirements": "Identifies where to send responses, may influence security permissions.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSH-24"
},
{
"identity": "rim",
"map": "./telecom[isNormalDatatype()]"
}
]
},
{
"id": "MessageHeader.responsible",
"path": "MessageHeader.responsible",
"short": "Final responsibility for event",
"definition": "The person or organization that accepts overall responsibility for the contents of the message. The implication is that the message event happened under the policies of the responsible party.",
"comment": "Usually only for the request, but can be used in a response.",
"requirements": "Need to know for audit/traceback requirements and possibly for authorization.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ORC-12 / PRT-5:PRT-4='OP' / PRT-8:PRT-4='OP' / ROL where ROL.3 is RO or ORC.11"
},
{
"identity": "rim",
"map": "unique(./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/participation[isHighest(priorityCode) and typeCode=\"RESP\" and isNormalParticipation]/role[classCode=\"ASSIGNED\" and isNormalRole()]/player[isNormalEntity() and classCode=\"PSN\" and determinerCode=\"INST\"] or ./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/participation[isHighest(priorityCode) and typeCode=\"RESP\" and isNormalParticipation]/role[classCode=\"ASSIGNED\" and isNormalRole()]/scoper[isNormalEntity() and classCode=\"ORG\" and determinerCode=\"INST\"])"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "MessageHeader.reason",
"path": "MessageHeader.reason",
"short": "Cause of event",
"definition": "Coded indication of the cause for the event - indicates a reason for the occurrence of the event that is a focus of this message.",
"requirements": "Need to be able to track why resources are being changed and report in the audit log/history of the resource. May affect authorization.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "EventReason"
}
],
"strength": "example",
"description": "Reason for event occurrence",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/message-reason-encounter"
}
},
"mapping": [
{
"identity": "v2",
"map": "EVN.4 / ORC.16 / OBR-31-reason for study / BPO-13-BP indication for use / RXO-20-indication / RXE-27-give indication / RXD-21-indication / RXG-22-indication / RXA-19-indication"
},
{
"identity": "rim",
"map": "unique(./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/reasonCode[isNormalDatatype()])"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MessageHeader.response",
"path": "MessageHeader.response",
"short": "If this is a reply to prior message",
"definition": "Information about the message that this message is a response to. Only present if this message is a response.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSA"
},
{
"identity": "rim",
"map": "./conveyedAcknowledgement"
}
]
},
{
"id": "MessageHeader.response.id",
"path": "MessageHeader.response.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MessageHeader.response.extension",
"path": "MessageHeader.response.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "MessageHeader.response.modifierExtension",
"path": "MessageHeader.response.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MessageHeader.response.identifier",
"path": "MessageHeader.response.identifier",
"short": "Id of original message",
"definition": "The MessageHeader.id of the message to which this message is a response.",
"requirements": "Allows receiver to know what message is being responded to.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSA-2"
},
{
"identity": "rim",
"map": "./acknowledges.id[isNormalDatatype()]"
}
]
},
{
"id": "MessageHeader.response.code",
"path": "MessageHeader.response.code",
"short": "ok | transient-error | fatal-error",
"definition": "Code that identifies the type of response to the message - whether it was successful or not, and whether it should be resent or not.",
"comment": "This is a generic response to the request message. Specific data for the response will be found in MessageHeader.focus.",
"requirements": "Allows the sender of the acknowledge message to know if the request was successful or if action is needed.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResponseType"
}
],
"strength": "required",
"description": "The kind of response to a message",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/response-code"
}
},
"mapping": [
{
"identity": "v2",
"map": "MSA-1"
},
{
"identity": "rim",
"map": "./typeCode[isNormalDatatype()]"
}
]
},
{
"id": "MessageHeader.response.details",
"path": "MessageHeader.response.details",
"short": "Specific list of hints/warnings/errors",
"definition": "Full details of any issues found in the message.",
"comment": "This SHALL be contained in the bundle. If any of the issues are errors, the response code SHALL be an error.",
"requirements": "Allows the sender of the message to determine what the specific issues are.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/OperationOutcome"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ERR"
},
{
"identity": "rim",
"map": "AcknowledgementDetail or Observation[classCode=\"ALRT\" and moodCode=\"EVN\"]"
}
]
},
{
"id": "MessageHeader.focus",
"path": "MessageHeader.focus",
"short": "The actual content of the message",
"definition": "The actual data of the message - a reference to the root/focus class of the event.",
"comment": "The data is defined where the transaction type is defined. The transaction data is always included in the bundle that is the full message. Only the root resource is specified. The resources it references should be contained in the bundle but are not also listed here. Multiple repetitions are allowed to cater for merges and other situations with multiple focal targets.",
"requirements": "Every message event is about actual data, a single resource, that is identified in the definition of the event, and perhaps some or all linked resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "unique(./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/participation[typeCode=\"SUBJ\" and isNormalParticipation]/role or ./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/outboundRelationship[typeCode=\"SBJ\" and isNormalActRelatoinship]/target)"
}
]
}
]
},
"differential": {
"element": [
{
"id": "MessageHeader",
"path": "MessageHeader",
"short": "A resource that describes a message that is exchanged between systems",
"definition": "The header for a message exchange that is either requesting or responding to an action. The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "v2",
"map": "MSH / MSA / ERR"
},
{
"identity": "rim",
"map": "Message"
},
{
"identity": "w5",
"map": "infrastructure.exchange"
}
]
},
{
"id": "MessageHeader.event",
"path": "MessageHeader.event",
"short": "Code for the event this message represents",
"definition": "Code that identifies the event this message represents and connects it with its definition. Events defined as part of the FHIR specification have the system value \"http://hl7.org/fhir/message-events\".",
"requirements": "Drives the behavior associated with this message.",
"min": 1,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MessageEvent"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "example",
"description": "One of the message events defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/message-events"
}
},
"mapping": [
{
"identity": "v2",
"map": "MSH-9.2"
},
{
"identity": "rim",
"map": "./payload[classCode=\"CACT\" and moodCode=\"EVN\" and isNormalAct()]/code[isNormalDatatype()]/code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "MessageHeader.destination",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "MessageDestination"
}
],
"path": "MessageHeader.destination",
"short": "Message destination application(s)",
"definition": "The destination application which the message is intended for.",
"comment": "There SHOULD be at least one destination, but in some circumstances, the source system is unaware of any particular destination system.",
"requirements": "Indicates where message is to be sent for routing purposes. Allows verification of \"am I the intended recipient\".",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "./communicationFunction[typeCode=\"RCV\"]"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MessageHeader.destination.name",
"path": "MessageHeader.destination.name",
"short": "Name of system",
"definition": "Human-readable name for the target system.",
"requirements": "May be used for routing of response and/or to support audit.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSH-5"
},
{
"identity": "rim",
"map": "unique(./entity[determinerCode=\"INST\" and (classCode=(\"DEV\", \"PSN\", \"ORG\"]/name[type='ST' and isNormalDatatype()])"
}
]
},
{
"id": "MessageHeader.destination.target",
"path": "MessageHeader.destination.target",
"short": "Particular delivery destination within the destination",
"definition": "Identifies the target end system in situations where the initial message transmission is to an intermediary system.",
"requirements": "Supports multi-hop routing.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "unique(./entity[determinerCode=\"INST\" and (classCode=(\"DEV\", \"PSN\", \"ORG\"]"
}
]
},
{
"id": "MessageHeader.destination.endpoint",
"path": "MessageHeader.destination.endpoint",
"short": "Actual destination address or id",
"definition": "Indicates where the message should be routed to.",
"comment": "The id may be a non-resolvable URI for systems that do not use standard network-based addresses.",
"requirements": "Identifies where to route the message.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSH-25 (or MSH-6)"
},
{
"identity": "rim",
"map": "./telecom"
}
]
},
{
"id": "MessageHeader.receiver",
"path": "MessageHeader.receiver",
"short": "Intended \"real-world\" recipient for the data",
"definition": "Allows data conveyed by a message to be addressed to a particular person or department when routing to a specific application isn't sufficient.",
"requirements": "Allows routing beyond just the application level.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRT-5:PRT-4='WAYR' / PRT-8:PRT-4='WAYR'"
},
{
"identity": "rim",
"map": "Not directly supported. Could be shared using attentionLine.value with an appropriate keyWordText"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MessageHeader.sender",
"path": "MessageHeader.sender",
"short": "Real world sender of the message",
"definition": "Identifies the sending system to allow the use of a trust relationship.",
"comment": "Use case is for where a (trusted) sending system is responsible for multiple organizations, and therefore cannot differentiate based on source endpoint / authentication alone.",
"requirements": "Allows routing beyond just the application level.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRT-5:PRT-4='WAYR' / PRT-8:PRT-4='WAYR'"
},
{
"identity": "rim",
"map": "Not directly supported. Could be shared using attentionLine.value with an appropriate keyWordText"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "MessageHeader.timestamp",
"path": "MessageHeader.timestamp",
"short": "Time that the message was sent",
"definition": "The time that the message was sent.",
"requirements": "Allows limited detection of out-of-order and delayed transmission. Also supports audit.",
"min": 1,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSH-7"
},
{
"identity": "rim",
"map": "./creationTime[isNormalDatatype()]"
},
{
"identity": "w5",
"map": "when.init"
}
]
},
{
"id": "MessageHeader.enterer",
"path": "MessageHeader.enterer",
"short": "The source of the data entry",
"definition": "The person or device that performed the data entry leading to this message. When there is more than one candidate, pick the most proximal to the message. Can provide other enterers in extensions.",
"comment": "Usually only for the request, but can be used in a response.",
"requirements": "Need to know for audit/traceback requirements and possibly for authorization.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "EVN-5 / ORC-10 / PRT-5:PRT-4='EP' / ROL where ROL.3 is EP or ORC.10"
},
{
"identity": "rim",
"map": "unique(./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/participation[typeCode=\"ENT\" and isNormalParticipation]/role[classCode=\"ASSIGNED\" and isNormalRole()]/player[isNormalEntity() and classCode=(\"DEV\", \"PSN\") and determinerCode=\"INST\"])"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "MessageHeader.author",
"path": "MessageHeader.author",
"short": "The source of the decision",
"definition": "The logical author of the message - the person or device that decided the described event should happen. When there is more than one candidate, pick the most proximal to the MessageHeader. Can provide other authors in extensions.",
"comment": "Usually only for the request, but can be used in a response.",
"requirements": "Need to know for audit/traceback requirements and possibly for authorization.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ORC-19 / PRT-5:PRT-4='AUT' / ROL where ROL.3 is IP or ORC.12"
},
{
"identity": "rim",
"map": "unique(./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/participation[isHighest(priorityCode) and typeCode=\"AUT\" and isNormalParticipation]/role[classCode=\"ASSIGNED\" and isNormalRole()]/player[isNormalEntity() and classCode=(\"DEV\", \"PSN\") and determinerCode=\"INST\"])"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "MessageHeader.source",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "MessageSource"
}
],
"path": "MessageHeader.source",
"short": "Message source application",
"definition": "The source application from which this message originated.",
"requirements": "Allows replies, supports audit.",
"min": 1,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "unique(./communicationFunction[typeCode=\"SND\"])"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "MessageHeader.source.name",
"path": "MessageHeader.source.name",
"short": "Name of system",
"definition": "Human-readable name for the source system.",
"requirements": "May be used to support audit.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSH-3"
},
{
"identity": "rim",
"map": "unique(./entity[determinerCode=\"INST\" and classCode=\"DEV\"]/name[type='ST' and isNormalDatatype()])"
}
]
},
{
"id": "MessageHeader.source.software",
"path": "MessageHeader.source.software",
"short": "Name of software running the system",
"definition": "May include configuration or other information useful in debugging.",
"requirements": "Supports audit and possibly interface engine behavior.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SFT-3 ( +SFT-1)"
},
{
"identity": "rim",
"map": "unique(./entity[determinerCode=\"INST\" and classCode=\"DEV\"]/softwareName[isNormalDatatype()])"
}
]
},
{
"id": "MessageHeader.source.version",
"path": "MessageHeader.source.version",
"short": "Version of software running",
"definition": "Can convey versions of multiple systems in situations where a message passes through multiple hands.",
"requirements": "Supports audit and possibly interface engine behavior.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SFT-2"
},
{
"identity": "rim",
"map": "(Not supported)"
}
]
},
{
"id": "MessageHeader.source.contact",
"path": "MessageHeader.source.contact",
"short": "Human contact for problems",
"definition": "An e-mail, phone, website or other contact point to use to resolve issues with message communications.",
"requirements": "Allows escalation of technical issues.",
"min": 0,
"max": "1",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "(MSH-22?)"
},
{
"identity": "rim",
"map": "unique(./entity[determinerCode=\"INST\" and classCode=\"DEV\"]/scopesRole[normalRole() and classCode=\"CON\" and layer[classCode=\"PSN\"]/telecom[isNormalDatatype()])"
}
]
},
{
"id": "MessageHeader.source.endpoint",
"path": "MessageHeader.source.endpoint",
"short": "Actual message source address or id",
"definition": "Identifies the routing target to send acknowledgements to.",
"comment": "The id may be a non-resolvable URI for systems that do not use standard network-based addresses.",
"requirements": "Identifies where to send responses, may influence security permissions.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSH-24"
},
{
"identity": "rim",
"map": "./telecom[isNormalDatatype()]"
}
]
},
{
"id": "MessageHeader.responsible",
"path": "MessageHeader.responsible",
"short": "Final responsibility for event",
"definition": "The person or organization that accepts overall responsibility for the contents of the message. The implication is that the message event happened under the policies of the responsible party.",
"comment": "Usually only for the request, but can be used in a response.",
"requirements": "Need to know for audit/traceback requirements and possibly for authorization.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ORC-12 / PRT-5:PRT-4='OP' / PRT-8:PRT-4='OP' / ROL where ROL.3 is RO or ORC.11"
},
{
"identity": "rim",
"map": "unique(./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/participation[isHighest(priorityCode) and typeCode=\"RESP\" and isNormalParticipation]/role[classCode=\"ASSIGNED\" and isNormalRole()]/player[isNormalEntity() and classCode=\"PSN\" and determinerCode=\"INST\"] or ./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/participation[isHighest(priorityCode) and typeCode=\"RESP\" and isNormalParticipation]/role[classCode=\"ASSIGNED\" and isNormalRole()]/scoper[isNormalEntity() and classCode=\"ORG\" and determinerCode=\"INST\"])"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "MessageHeader.reason",
"path": "MessageHeader.reason",
"short": "Cause of event",
"definition": "Coded indication of the cause for the event - indicates a reason for the occurrence of the event that is a focus of this message.",
"requirements": "Need to be able to track why resources are being changed and report in the audit log/history of the resource. May affect authorization.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "EventReason"
}
],
"strength": "example",
"description": "Reason for event occurrence",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/message-reason-encounter"
}
},
"mapping": [
{
"identity": "v2",
"map": "EVN.4 / ORC.16 / OBR-31-reason for study / BPO-13-BP indication for use / RXO-20-indication / RXE-27-give indication / RXD-21-indication / RXG-22-indication / RXA-19-indication"
},
{
"identity": "rim",
"map": "unique(./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/reasonCode[isNormalDatatype()])"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "MessageHeader.response",
"path": "MessageHeader.response",
"short": "If this is a reply to prior message",
"definition": "Information about the message that this message is a response to. Only present if this message is a response.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSA"
},
{
"identity": "rim",
"map": "./conveyedAcknowledgement"
}
]
},
{
"id": "MessageHeader.response.identifier",
"path": "MessageHeader.response.identifier",
"short": "Id of original message",
"definition": "The MessageHeader.id of the message to which this message is a response.",
"requirements": "Allows receiver to know what message is being responded to.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "MSA-2"
},
{
"identity": "rim",
"map": "./acknowledges.id[isNormalDatatype()]"
}
]
},
{
"id": "MessageHeader.response.code",
"path": "MessageHeader.response.code",
"short": "ok | transient-error | fatal-error",
"definition": "Code that identifies the type of response to the message - whether it was successful or not, and whether it should be resent or not.",
"comment": "This is a generic response to the request message. Specific data for the response will be found in MessageHeader.focus.",
"requirements": "Allows the sender of the acknowledge message to know if the request was successful or if action is needed.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResponseType"
}
],
"strength": "required",
"description": "The kind of response to a message",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/response-code"
}
},
"mapping": [
{
"identity": "v2",
"map": "MSA-1"
},
{
"identity": "rim",
"map": "./typeCode[isNormalDatatype()]"
}
]
},
{
"id": "MessageHeader.response.details",
"path": "MessageHeader.response.details",
"short": "Specific list of hints/warnings/errors",
"definition": "Full details of any issues found in the message.",
"comment": "This SHALL be contained in the bundle. If any of the issues are errors, the response code SHALL be an error.",
"requirements": "Allows the sender of the message to determine what the specific issues are.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/OperationOutcome"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ERR"
},
{
"identity": "rim",
"map": "AcknowledgementDetail or Observation[classCode=\"ALRT\" and moodCode=\"EVN\"]"
}
]
},
{
"id": "MessageHeader.focus",
"path": "MessageHeader.focus",
"short": "The actual content of the message",
"definition": "The actual data of the message - a reference to the root/focus class of the event.",
"comment": "The data is defined where the transaction type is defined. The transaction data is always included in the bundle that is the full message. Only the root resource is specified. The resources it references should be contained in the bundle but are not also listed here. Multiple repetitions are allowed to cater for merges and other situations with multiple focal targets.",
"requirements": "Every message event is about actual data, a single resource, that is identified in the definition of the event, and perhaps some or all linked resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "unique(./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/participation[typeCode=\"SUBJ\" and isNormalParticipation]/role or ./controlAct[classCode=\"CACT\" and classCode=\"EVN\" and isNormalAct()]/outboundRelationship[typeCode=\"SBJ\" and isNormalActRelatoinship]/target)"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/NamingSystem",
"resource": {
"resourceType": "StructureDefinition",
"id": "NamingSystem",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints NamingSystem I DomainResource System of unique identification
+ Root systems cannot have uuid identifiers
+ Can only have replacedBy if naming system is retired
+ Can't have more than one preferred identifier for a type
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension name Σ 1..1 string Name for this naming system (computer friendly) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) kind 1..1 code codesystem | identifier | root
NamingSystemType (Required) date Σ 1..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) contact Σ 0..* ContactDetail Contact details for the publisher
responsible 0..1 string Who maintains system namespace? type 0..1 CodeableConcept e.g. driver, provider, patient, bank etc.
Identifier Type Codes (Extensible) description 0..1 markdown Natural language description of the naming system useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for naming system (if applicable)
Jurisdiction ValueSet (Extensible)
usage 0..1 string How/where is it used uniqueId 1..* BackboneElement Unique identifiers used for system
type 1..1 code oid | uuid | uri | other
NamingSystemIdentifierType (Required) value 1..1 string The unique identifier preferred 0..1 boolean Is this the id that should be used for this type comment 0..1 string Notes about identifier usage period 0..1 Period When is identifier valid? replacedBy I 0..1 Reference(NamingSystem) Use this instead
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 1
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/NamingSystem",
"name": "NamingSystem",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for NamingSystem Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "NamingSystem",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"_baseDefinition": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-codegen-super",
"valueString": "MetadataResource"
}
]
},
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "NamingSystem",
"path": "NamingSystem",
"short": "System of unique identification",
"definition": "A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc. Represents a \"System\" used within the Identifier and Coding data types.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "nsd-1",
"severity": "error",
"human": "Root systems cannot have uuid identifiers",
"expression": "kind != 'root' or uniqueId.type = 'uuid'",
"xpath": "not(f:kind/@value='root' and f:uniqueId/f:type/@value='uuid')"
},
{
"key": "nsd-3",
"severity": "error",
"human": "Can only have replacedBy if naming system is retired",
"expression": "replacedBy.empty() or status = 'retired'",
"xpath": "not(f:replacedBy) or f:status/@value='retired'"
},
{
"key": "nsd-2",
"severity": "error",
"human": "Can't have more than one preferred identifier for a type",
"expression": "uniqueId.where(preferred = true).select(type).isDistinct()",
"xpath": "not(exists(for $type in distinct-values(f:uniqueId/f:type/@value) return if (count(f:uniqueId[f:type/@value=$type and f:preferred/@value=true()])>1) then $type else ()))"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "conformance.terminology"
}
]
},
{
"id": "NamingSystem.id",
"path": "NamingSystem.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "NamingSystem.meta",
"path": "NamingSystem.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "NamingSystem.implicitRules",
"path": "NamingSystem.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "NamingSystem.language",
"path": "NamingSystem.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "NamingSystem.text",
"path": "NamingSystem.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "NamingSystem.contained",
"path": "NamingSystem.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NamingSystem.extension",
"path": "NamingSystem.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NamingSystem.modifierExtension",
"path": "NamingSystem.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NamingSystem.name",
"path": "NamingSystem.name",
"short": "Name for this naming system (computer friendly)",
"definition": "A natural language name identifying the naming system. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly. The\"symbolic name\" for an OID would be captured as an extension.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "NamingSystem.status",
"path": "NamingSystem.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this naming system. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of naming systems that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired naming system without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "NamingSystem.kind",
"path": "NamingSystem.kind",
"short": "codesystem | identifier | root",
"definition": "Indicates the purpose for the naming system - what kinds of things does it make unique?",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NamingSystemType"
}
],
"strength": "required",
"description": "Identifies the purpose of the naming system.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/namingsystem-type"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "NamingSystem.date",
"path": "NamingSystem.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the naming system was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the naming system changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the naming system. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 1,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "NamingSystem.publisher",
"path": "NamingSystem.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the naming system.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the naming system is the organization or individual primarily responsible for the maintenance and upkeep of the naming system. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the naming system. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the naming system. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "NamingSystem.contact",
"path": "NamingSystem.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "NamingSystem.responsible",
"path": "NamingSystem.responsible",
"short": "Who maintains system namespace?",
"definition": "The name of the organization that is responsible for issuing identifiers or codes for this namespace and ensuring their non-collision.",
"comment": "This is the primary organization. Responsibility for some aspects of a namespace may be delegated.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "NamingSystem.type",
"path": "NamingSystem.type",
"short": "e.g. driver, provider, patient, bank etc.",
"definition": "Categorizes a naming system for easier search by grouping related naming systems.",
"comment": "This will most commonly be used for identifier namespaces, but categories could potentially be useful for code systems and authorities as well.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "IdentifierType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A coded type for an identifier that can be used to determine which identifier to use for a specific purpose.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/identifier-type"
}
}
},
{
"id": "NamingSystem.description",
"path": "NamingSystem.description",
"short": "Natural language description of the naming system",
"definition": "A free text natural language description of the naming system from a consumer's perspective. Details about what the namespace identifies including scope, granularity, version labeling, etc.",
"comment": "This description can be used to capture details such as why the naming system was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the naming system as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "NamingSystem.useContext",
"path": "NamingSystem.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate naming system instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "NamingSystem.jurisdiction",
"path": "NamingSystem.jurisdiction",
"short": "Intended jurisdiction for naming system (if applicable)",
"definition": "A legal or geographic region in which the naming system is intended to be used.",
"comment": "It may be possible for the naming system to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "NamingSystem.usage",
"path": "NamingSystem.usage",
"short": "How/where is it used",
"definition": "Provides guidance on the use of the namespace, including the handling of formatting characters, use of upper vs. lower case, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "NamingSystem.uniqueId",
"path": "NamingSystem.uniqueId",
"short": "Unique identifiers used for system",
"definition": "Indicates how the system may be identified when referenced in electronic exchange.",
"comment": "Multiple identifiers may exist, either due to duplicate registration, regional rules, needs of different communication technologies, etc.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "NamingSystem.uniqueId.id",
"path": "NamingSystem.uniqueId.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NamingSystem.uniqueId.extension",
"path": "NamingSystem.uniqueId.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NamingSystem.uniqueId.modifierExtension",
"path": "NamingSystem.uniqueId.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NamingSystem.uniqueId.type",
"path": "NamingSystem.uniqueId.type",
"short": "oid | uuid | uri | other",
"definition": "Identifies the unique identifier scheme used for this particular identifier.",
"comment": "Different identifier types may be used in different types of communications (OIDs for v3, URIs for FHIR, etc.). Other includes RUIDs from v3, standard v2 code name strings, etc.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NamingSystemIdentifierType"
}
],
"strength": "required",
"description": "Identifies the style of unique identifier used to identify a namespace.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/namingsystem-identifier-type"
}
}
},
{
"id": "NamingSystem.uniqueId.value",
"path": "NamingSystem.uniqueId.value",
"short": "The unique identifier",
"definition": "The string that should be sent over the wire to identify the code system or identifier system.",
"comment": "If the value is a URI intended for use as FHIR system identifier, the URI should not contain \"\\\" or \"?\" or \",\" since this makes escaping very difficult.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "NamingSystem.uniqueId.preferred",
"path": "NamingSystem.uniqueId.preferred",
"short": "Is this the id that should be used for this type",
"definition": "Indicates whether this identifier is the \"preferred\" identifier of this type.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"meaningWhenMissing": "If there are multiple ids, and one is labeled \"preferred\", then the assumption is that the others are not preferred. In the absence of any id marked as preferred, no inference can be drawn"
},
{
"id": "NamingSystem.uniqueId.comment",
"path": "NamingSystem.uniqueId.comment",
"short": "Notes about identifier usage",
"definition": "Notes about the past or intended usage of this identifier.",
"comment": "e.g. \"must be used in Germany\" or \"was initially published in error with this value\".",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "NamingSystem.uniqueId.period",
"path": "NamingSystem.uniqueId.period",
"short": "When is identifier valid?",
"definition": "Identifies the period of time over which this identifier is considered appropriate to refer to the naming system. Outside of this window, the identifier might be non-deterministic.",
"comment": "Within a registry, a given identifier should only be \"active\" for a single namespace at a time. (Ideally, an identifier should only ever be associated with a single namespace across all time).",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
]
},
{
"id": "NamingSystem.replacedBy",
"path": "NamingSystem.replacedBy",
"short": "Use this instead",
"definition": "For naming systems that are retired, indicates the naming system that should be used in their place (if any).",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/NamingSystem"
}
],
"condition": [
"nsd-3"
]
}
]
},
"differential": {
"element": [
{
"id": "NamingSystem",
"path": "NamingSystem",
"short": "System of unique identification",
"definition": "A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc. Represents a \"System\" used within the Identifier and Coding data types.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "nsd-1",
"severity": "error",
"human": "Root systems cannot have uuid identifiers",
"expression": "kind != 'root' or uniqueId.type = 'uuid'",
"xpath": "not(f:kind/@value='root' and f:uniqueId/f:type/@value='uuid')"
},
{
"key": "nsd-3",
"severity": "error",
"human": "Can only have replacedBy if naming system is retired",
"expression": "replacedBy.empty() or status = 'retired'",
"xpath": "not(f:replacedBy) or f:status/@value='retired'"
},
{
"key": "nsd-2",
"severity": "error",
"human": "Can't have more than one preferred identifier for a type",
"expression": "uniqueId.where(preferred = true).select(type).isDistinct()",
"xpath": "not(exists(for $type in distinct-values(f:uniqueId/f:type/@value) return if (count(f:uniqueId[f:type/@value=$type and f:preferred/@value=true()])>1) then $type else ()))"
}
],
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "conformance.terminology"
}
]
},
{
"id": "NamingSystem.name",
"path": "NamingSystem.name",
"short": "Name for this naming system (computer friendly)",
"definition": "A natural language name identifying the naming system. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly. The\"symbolic name\" for an OID would be captured as an extension.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "NamingSystem.status",
"path": "NamingSystem.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this naming system. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of naming systems that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired naming system without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "NamingSystem.kind",
"path": "NamingSystem.kind",
"short": "codesystem | identifier | root",
"definition": "Indicates the purpose for the naming system - what kinds of things does it make unique?",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NamingSystemType"
}
],
"strength": "required",
"description": "Identifies the purpose of the naming system.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/namingsystem-type"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "NamingSystem.date",
"path": "NamingSystem.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the naming system was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the naming system changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the naming system. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 1,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "NamingSystem.publisher",
"path": "NamingSystem.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the naming system.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the naming system is the organization or individual primarily responsible for the maintenance and upkeep of the naming system. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the naming system. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the naming system. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "NamingSystem.contact",
"path": "NamingSystem.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "NamingSystem.responsible",
"path": "NamingSystem.responsible",
"short": "Who maintains system namespace?",
"definition": "The name of the organization that is responsible for issuing identifiers or codes for this namespace and ensuring their non-collision.",
"comment": "This is the primary organization. Responsibility for some aspects of a namespace may be delegated.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "NamingSystem.type",
"path": "NamingSystem.type",
"short": "e.g. driver, provider, patient, bank etc.",
"definition": "Categorizes a naming system for easier search by grouping related naming systems.",
"comment": "This will most commonly be used for identifier namespaces, but categories could potentially be useful for code systems and authorities as well.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "IdentifierType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A coded type for an identifier that can be used to determine which identifier to use for a specific purpose.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/identifier-type"
}
}
},
{
"id": "NamingSystem.description",
"path": "NamingSystem.description",
"short": "Natural language description of the naming system",
"definition": "A free text natural language description of the naming system from a consumer's perspective. Details about what the namespace identifies including scope, granularity, version labeling, etc.",
"comment": "This description can be used to capture details such as why the naming system was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the naming system as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "NamingSystem.useContext",
"path": "NamingSystem.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate naming system instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "NamingSystem.jurisdiction",
"path": "NamingSystem.jurisdiction",
"short": "Intended jurisdiction for naming system (if applicable)",
"definition": "A legal or geographic region in which the naming system is intended to be used.",
"comment": "It may be possible for the naming system to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "NamingSystem.usage",
"path": "NamingSystem.usage",
"short": "How/where is it used",
"definition": "Provides guidance on the use of the namespace, including the handling of formatting characters, use of upper vs. lower case, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "NamingSystem.uniqueId",
"path": "NamingSystem.uniqueId",
"short": "Unique identifiers used for system",
"definition": "Indicates how the system may be identified when referenced in electronic exchange.",
"comment": "Multiple identifiers may exist, either due to duplicate registration, regional rules, needs of different communication technologies, etc.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "NamingSystem.uniqueId.type",
"path": "NamingSystem.uniqueId.type",
"short": "oid | uuid | uri | other",
"definition": "Identifies the unique identifier scheme used for this particular identifier.",
"comment": "Different identifier types may be used in different types of communications (OIDs for v3, URIs for FHIR, etc.). Other includes RUIDs from v3, standard v2 code name strings, etc.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NamingSystemIdentifierType"
}
],
"strength": "required",
"description": "Identifies the style of unique identifier used to identify a namespace.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/namingsystem-identifier-type"
}
}
},
{
"id": "NamingSystem.uniqueId.value",
"path": "NamingSystem.uniqueId.value",
"short": "The unique identifier",
"definition": "The string that should be sent over the wire to identify the code system or identifier system.",
"comment": "If the value is a URI intended for use as FHIR system identifier, the URI should not contain \"\\\" or \"?\" or \",\" since this makes escaping very difficult.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "NamingSystem.uniqueId.preferred",
"path": "NamingSystem.uniqueId.preferred",
"short": "Is this the id that should be used for this type",
"definition": "Indicates whether this identifier is the \"preferred\" identifier of this type.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"meaningWhenMissing": "If there are multiple ids, and one is labeled \"preferred\", then the assumption is that the others are not preferred. In the absence of any id marked as preferred, no inference can be drawn"
},
{
"id": "NamingSystem.uniqueId.comment",
"path": "NamingSystem.uniqueId.comment",
"short": "Notes about identifier usage",
"definition": "Notes about the past or intended usage of this identifier.",
"comment": "e.g. \"must be used in Germany\" or \"was initially published in error with this value\".",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "NamingSystem.uniqueId.period",
"path": "NamingSystem.uniqueId.period",
"short": "When is identifier valid?",
"definition": "Identifies the period of time over which this identifier is considered appropriate to refer to the naming system. Outside of this window, the identifier might be non-deterministic.",
"comment": "Within a registry, a given identifier should only be \"active\" for a single namespace at a time. (Ideally, an identifier should only ever be associated with a single namespace across all time).",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
]
},
{
"id": "NamingSystem.replacedBy",
"path": "NamingSystem.replacedBy",
"short": "Use this instead",
"definition": "For naming systems that are retired, indicates the naming system that should be used in their place (if any).",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/NamingSystem"
}
],
"condition": [
"nsd-3"
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/NutritionOrder",
"resource": {
"resourceType": "StructureDefinition",
"id": "NutritionOrder",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints NutritionOrder I DomainResource Diet, formula or nutritional supplement request
+ Nutrition Order SHALL contain either Oral Diet , Supplement, or Enteral Formula class
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..* Identifier Identifiers assigned to this order
status ?!Σ 0..1 code proposed | draft | planned | requested | active | on-hold | completed | cancelled | entered-in-error
NutritionOrderStatus (Required) patient Σ 1..1 Reference(Patient) The person who requires the diet, formula or nutritional supplement encounter 0..1 Reference(Encounter) The encounter associated with this nutrition order dateTime Σ 1..1 dateTime Date and time the nutrition order was requested orderer Σ 0..1 Reference(Practitioner) Who ordered the diet, formula or nutritional supplement allergyIntolerance 0..* Reference(AllergyIntolerance) List of the patient's food and nutrition-related allergies and intolerances
foodPreferenceModifier 0..* CodeableConcept Order-specific modifier about the type of food that should be given
Diet (Example)
excludeFoodModifier 0..* CodeableConcept Order-specific modifier about the type of food that should not be given
Food Type Codes (Example)
oralDiet I 0..1 BackboneElement Oral diet components type Σ 0..* CodeableConcept Type of oral diet or diet restrictions that describe what can be consumed orally
Diet Codes (Example)
schedule 0..* Timing Scheduled frequency of diet
nutrient 0..* BackboneElement Required nutrient modifications
modifier 0..1 CodeableConcept Type of nutrient that is being modified
Nutrient Modifier Codes (Example) amount 0..1 SimpleQuantity Quantity of the specified nutrient texture 0..* BackboneElement Required texture modifications
modifier 0..1 CodeableConcept Code to indicate how to alter the texture of the foods, e.g. pureed
Texture Modifier Codes (Example) foodType 0..1 CodeableConcept Concepts that are used to identify an entity that is ingested for nutritional purposes
Texture Modified Food Type Codes (Example) fluidConsistencyType 0..* CodeableConcept The required consistency of fluids and liquids provided to the patient
Fluid Consistency Type Codes (Example)
instruction Σ 0..1 string Instructions or additional information about the oral diet supplement I 0..* BackboneElement Supplement components
type Σ 0..1 CodeableConcept Type of supplement product requested
Supplement Type Codes (Example) productName 0..1 string Product or brand name of the nutritional supplement schedule 0..* Timing Scheduled frequency of supplement
quantity 0..1 SimpleQuantity Amount of the nutritional supplement instruction Σ 0..1 string Instructions or additional information about the oral supplement enteralFormula I 0..1 BackboneElement Enteral formula components baseFormulaType Σ 0..1 CodeableConcept Type of enteral or infant formula
Enteral Formula Type Codes (Example) baseFormulaProductName 0..1 string Product or brand name of the enteral or infant formula additiveType 0..1 CodeableConcept Type of modular component to add to the feeding
Enteral Formula Additive Type Code (Example) additiveProductName 0..1 string Product or brand name of the modular additive caloricDensity 0..1 SimpleQuantity Amount of energy per specified volume that is required routeofAdministration 0..1 CodeableConcept How the formula should enter the patient's gastrointestinal tract
Enteral Route Codes (Extensible) administration 0..* BackboneElement Formula feeding instruction as structured data
schedule 0..1 Timing Scheduled frequency of enteral feeding quantity 0..1 SimpleQuantity The volume of formula to provide rate[x] 0..1 Speed with which the formula is provided per period of time rateQuantity SimpleQuantity rateRatio Ratio maxVolumeToDeliver 0..1 SimpleQuantity Upper limit on formula volume per unit of time administrationInstruction Σ 0..1 string Formula feeding instructions expressed as text
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "oo"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/NutritionOrder",
"name": "NutritionOrder",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Orders and Observations)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/orders/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for NutritionOrder Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "NutritionOrder",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "NutritionOrder",
"path": "NutritionOrder",
"short": "Diet, formula or nutritional supplement request",
"definition": "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident.",
"comment": "Referenced by an Order Request (workflow).",
"alias": [
"Nutrition Order",
"Diet Order",
"Diet",
"Nutritional Supplement",
"Enteral Nutrition"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "nor-1",
"severity": "warning",
"human": "Nutrition Order SHALL contain either Oral Diet , Supplement, or Enteral Formula class",
"expression": "oralDiet.exists() or supplement.exists() or enteralFormula.exists()",
"xpath": "exists(f:oralDiet) or exists(f:supplement) or exists(f:enteralFormula)"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "rim",
"map": "SupplyRequest"
},
{
"identity": "w5",
"map": "clinical.careprovision"
}
]
},
{
"id": "NutritionOrder.id",
"path": "NutritionOrder.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "NutritionOrder.meta",
"path": "NutritionOrder.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "NutritionOrder.implicitRules",
"path": "NutritionOrder.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "NutritionOrder.language",
"path": "NutritionOrder.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "NutritionOrder.text",
"path": "NutritionOrder.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "NutritionOrder.contained",
"path": "NutritionOrder.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.extension",
"path": "NutritionOrder.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.modifierExtension",
"path": "NutritionOrder.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.identifier",
"path": "NutritionOrder.identifier",
"short": "Identifiers assigned to this order",
"definition": "Identifiers assigned to this order by the order sender or by the order receiver.",
"comment": "The Identifier.type element can be to indicate filler vs. placer if needed. This is explained in further detail [here](procedurerequest.html#notes).",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "NutritionOrder.status",
"path": "NutritionOrder.status",
"short": "proposed | draft | planned | requested | active | on-hold | completed | cancelled | entered-in-error",
"definition": "The workflow status of the nutrition order/request.",
"comment": "Typically the system placing the order sets the status to \"requested\". Thereafter, the order is maintained by the receiver that updates the status as the request is handled.\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NutritionOrderStatus"
}
],
"strength": "required",
"description": "Codes specifying the state of the request. Describes the lifecycle of the nutrition order.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/nutrition-request-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "NutritionOrder.patient",
"path": "NutritionOrder.patient",
"short": "The person who requires the diet, formula or nutritional supplement",
"definition": "The person (patient) who needs the nutrition order for an oral diet, nutritional supplement and/or enteral or formula feeding.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.subject.reference(Patient)"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "NutritionOrder.encounter",
"path": "NutritionOrder.encounter",
"short": "The encounter associated with this nutrition order",
"definition": "An encounter that provides additional information about the healthcare context in which this request is made.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.context.reference(Encounter)"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "NutritionOrder.dateTime",
"path": "NutritionOrder.dateTime",
"short": "Date and time the nutrition order was requested",
"definition": "The date and time that this nutrition order was requested.",
"min": 1,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "rim",
"map": "author.time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "NutritionOrder.orderer",
"path": "NutritionOrder.orderer",
"short": "Who ordered the diet, formula or nutritional supplement",
"definition": "The practitioner that holds legal responsibility for ordering the diet, nutritional supplement, or formula feedings.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "NutritionOrder.allergyIntolerance",
"path": "NutritionOrder.allergyIntolerance",
"short": "List of the patient's food and nutrition-related allergies and intolerances",
"definition": "A link to a record of allergies or intolerances which should be included in the nutrition order.",
"comment": "Information on a patient's food allergies and intolerances to inform healthcare personnel about the type of foods that the patient shouldn't receive or consume.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/AllergyIntolerance"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON].target[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "NutritionOrder.foodPreferenceModifier",
"path": "NutritionOrder.foodPreferenceModifier",
"short": "Order-specific modifier about the type of food that should be given",
"definition": "This modifier is used to convey order-specific modifiers about the type of food that should be given. These can be derived from patient allergies, intolerances, or preferences such as Halal, Vegan or Kosher. This modifier applies to the entire nutrition order inclusive of the oral diet, nutritional supplements and enteral formula feedings.",
"comment": "Information on a patient's food preferences that inform healthcare personnel about the food that the patient should receive or consume.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PatientDiet"
}
],
"strength": "example",
"description": "Medical, cultural or ethical food preferences to help with catering requirements",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/encounter-diet"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship [typeCode =COMP], target [classCode=PROC, moodCode=EVN, code=NutritionModificationType]"
}
]
},
{
"id": "NutritionOrder.excludeFoodModifier",
"path": "NutritionOrder.excludeFoodModifier",
"short": "Order-specific modifier about the type of food that should not be given",
"definition": "This modifier is used to convey order-specific modifiers about the type of food that should NOT be given. These can be derived from patient allergies, intolerances, or preferences such as No Red Meat, No Soy or No Wheat or Gluten-Free. While it should not be necessary to repeat allergy or intolerance information captured in the referenced AllergyIntolerance resource in the excludeFoodModifier, this element may be used to convey additional specificity related to foods that should be eliminated from the patient’s diet for any reason. This modifier applies to the entire nutrition order inclusive of the oral diet, nutritional supplements and enteral formula feedings.",
"comment": "Information on a patient's food allergies, intolerances and preferences to inform healthcare personnel about the type of foods that the patient shouldn't receive or consume.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FoodType"
}
],
"strength": "example",
"description": "Codes used to indicate the type of food that should NOT be given to the patient.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/food-type"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.oralDiet",
"path": "NutritionOrder.oralDiet",
"short": "Oral diet components",
"definition": "Diet given orally in contrast to enteral (tube) feeding.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"nor-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": "oralDiet .outboundRelationship [typeCode =COMP], target [classCode=SPLY, moodCode=RQO, code=OralDietSupplyType]"
}
]
},
{
"id": "NutritionOrder.oralDiet.id",
"path": "NutritionOrder.oralDiet.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.oralDiet.extension",
"path": "NutritionOrder.oralDiet.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.oralDiet.modifierExtension",
"path": "NutritionOrder.oralDiet.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.oralDiet.type",
"path": "NutritionOrder.oralDiet.type",
"short": "Type of oral diet or diet restrictions that describe what can be consumed orally",
"definition": "The kind of diet or dietary restriction such as fiber restricted diet or diabetic diet.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "OralDiet"
}
],
"strength": "example",
"description": "Codes used to indicate the type of diet being ordered for a patient.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/diet-type"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "NutritionOrder.oralDiet.schedule",
"path": "NutritionOrder.oralDiet.schedule",
"short": "Scheduled frequency of diet",
"definition": "The time period and frequency at which the diet should be given. The diet should be given for the combination of all schedules if more than one schedule is present.",
"alias": [
"Frequency"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Timing"
}
],
"mapping": [
{
"identity": "rim",
"map": ".expectedUseTime"
}
]
},
{
"id": "NutritionOrder.oralDiet.nutrient",
"path": "NutritionOrder.oralDiet.nutrient",
"short": "Required nutrient modifications",
"definition": "Class that defines the quantity and type of nutrient modifications (for example carbohydrate, fiber or sodium) required for the oral diet.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation{typeCode=PRD].role{classCode=MANU), manufacturedFoodKind"
}
]
},
{
"id": "NutritionOrder.oralDiet.nutrient.id",
"path": "NutritionOrder.oralDiet.nutrient.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.oralDiet.nutrient.extension",
"path": "NutritionOrder.oralDiet.nutrient.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.oralDiet.nutrient.modifierExtension",
"path": "NutritionOrder.oralDiet.nutrient.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.oralDiet.nutrient.modifier",
"path": "NutritionOrder.oralDiet.nutrient.modifier",
"short": "Type of nutrient that is being modified",
"definition": "The nutrient that is being modified such as carbohydrate or sodium.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NutrientModifier"
}
],
"strength": "example",
"description": "Codes for types of nutrient that is being modified such as carbohydrate or sodium.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/nutrient-code"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "NutritionOrder.oralDiet.nutrient.amount",
"path": "NutritionOrder.oralDiet.nutrient.amount",
"short": "Quantity of the specified nutrient",
"definition": "The quantity of the specified nutrient to include in diet.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "NutritionOrder.oralDiet.texture",
"path": "NutritionOrder.oralDiet.texture",
"short": "Required texture modifications",
"definition": "Class that describes any texture modifications required for the patient to safely consume various types of solid foods.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship [typeCode =COMP], target [classCode=PROC, moodCode=EVN, code=DietTextureModificationType]"
}
]
},
{
"id": "NutritionOrder.oralDiet.texture.id",
"path": "NutritionOrder.oralDiet.texture.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.oralDiet.texture.extension",
"path": "NutritionOrder.oralDiet.texture.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.oralDiet.texture.modifierExtension",
"path": "NutritionOrder.oralDiet.texture.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.oralDiet.texture.modifier",
"path": "NutritionOrder.oralDiet.texture.modifier",
"short": "Code to indicate how to alter the texture of the foods, e.g. pureed",
"definition": "Any texture modifications (for solid foods) that should be made, e.g. easy to chew, chopped, ground, and pureed.",
"comment": "Coupled with the foodType (Meat).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TextureModifier"
}
],
"strength": "example",
"description": "Codes for food consistency types or texture modifications to apply to foods.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/texture-code"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "NutritionOrder.oralDiet.texture.foodType",
"path": "NutritionOrder.oralDiet.texture.foodType",
"short": "Concepts that are used to identify an entity that is ingested for nutritional purposes",
"definition": "The food type(s) (e.g. meats, all foods) that the texture modification applies to. This could be all foods types.",
"comment": "Coupled with the textureModifier; could be (All Foods).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TextureModifiedFoodType"
}
],
"strength": "example",
"description": "Codes for types of foods that are texture modified.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/modified-foodtype"
}
},
"mapping": [
{
"identity": "rim",
"map": ".participation{typeCode=PRD].role{classCode=MANU), manufacturedFoodKind; .code"
}
]
},
{
"id": "NutritionOrder.oralDiet.fluidConsistencyType",
"path": "NutritionOrder.oralDiet.fluidConsistencyType",
"short": "The required consistency of fluids and liquids provided to the patient",
"definition": "The required consistency (e.g. honey-thick, nectar-thick, thin, thickened.) of liquids or fluids served to the patient.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FluidConsistencyType"
}
],
"strength": "example",
"description": "Codes used to represent the consistency of fluids and liquids provided to the patient.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/consistency-type"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code (Not differentiated from dietTextureModificationType in HL7 v3)"
}
]
},
{
"id": "NutritionOrder.oralDiet.instruction",
"path": "NutritionOrder.oralDiet.instruction",
"short": "Instructions or additional information about the oral diet",
"definition": "Free text or additional instructions or information pertaining to the oral diet.",
"comment": "Free text dosage instructions can be used for cases where the instructions are too complex to code.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "NutritionOrder.supplement",
"path": "NutritionOrder.supplement",
"short": "Supplement components",
"definition": "Oral nutritional products given in order to add further nutritional value to the patient's diet.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"nor-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship [typeCode =COMP], target [classCode=SPLY, moodCode=RQO, code=SUPPLEMENT]"
}
]
},
{
"id": "NutritionOrder.supplement.id",
"path": "NutritionOrder.supplement.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.supplement.extension",
"path": "NutritionOrder.supplement.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.supplement.modifierExtension",
"path": "NutritionOrder.supplement.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.supplement.type",
"path": "NutritionOrder.supplement.type",
"short": "Type of supplement product requested",
"definition": "The kind of nutritional supplement product required such as a high protein or pediatric clear liquid supplement.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplementType"
}
],
"strength": "example",
"description": "Codes for nutritional supplements to be provided to the patient",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplement-type"
}
},
"mapping": [
{
"identity": "rim",
"map": ".participation{typeCode=PRD].role{classCode=MANU), manufacturedFoodKind; .code (NutritionalSupplementType)"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "NutritionOrder.supplement.productName",
"path": "NutritionOrder.supplement.productName",
"short": "Product or brand name of the nutritional supplement",
"definition": "The product or brand name of the nutritional supplement such as \"Acme Protein Shake\".",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "NutritionOrder.supplement.schedule",
"path": "NutritionOrder.supplement.schedule",
"short": "Scheduled frequency of supplement",
"definition": "The time period and frequency at which the supplement(s) should be given. The supplement should be given for the combination of all schedules if more than one schedule is present.",
"alias": [
"Frequency"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Timing"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "NutritionOrder.supplement.quantity",
"path": "NutritionOrder.supplement.quantity",
"short": "Amount of the nutritional supplement",
"definition": "The amount of the nutritional supplement to be given.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "NutritionOrder.supplement.instruction",
"path": "NutritionOrder.supplement.instruction",
"short": "Instructions or additional information about the oral supplement",
"definition": "Free text or additional instructions or information pertaining to the oral supplement.",
"comment": "Free text dosage instructions can be used for cases where the instructions are too complex to code.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "NutritionOrder.enteralFormula",
"path": "NutritionOrder.enteralFormula",
"short": "Enteral formula components",
"definition": "Feeding provided through the gastrointestinal tract via a tube, catheter, or stoma that delivers nutrition distal to the oral cavity.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"nor-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship [typeCode =COMP], target [classCode=SPLY, moodCode=RQO, code=FORMULA]"
}
]
},
{
"id": "NutritionOrder.enteralFormula.id",
"path": "NutritionOrder.enteralFormula.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.enteralFormula.extension",
"path": "NutritionOrder.enteralFormula.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.enteralFormula.modifierExtension",
"path": "NutritionOrder.enteralFormula.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.enteralFormula.baseFormulaType",
"path": "NutritionOrder.enteralFormula.baseFormulaType",
"short": "Type of enteral or infant formula",
"definition": "The type of enteral or infant formula such as an adult standard formula with fiber or a soy-based infant formula.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "EnteralFormulaType"
}
],
"strength": "example",
"description": "Codes for type of enteral formula to be administered to patient.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/entformula-type"
}
},
"mapping": [
{
"identity": "rim",
"map": ".participation{typeCode=PRD].role{classCode=MANU), manufacturedFoodKind; .code (NutritionalFormulaType)"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "NutritionOrder.enteralFormula.baseFormulaProductName",
"path": "NutritionOrder.enteralFormula.baseFormulaProductName",
"short": "Product or brand name of the enteral or infant formula",
"definition": "The product or brand name of the enteral or infant formula product such as \"ACME Adult Standard Formula\".",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "NutritionOrder.enteralFormula.additiveType",
"path": "NutritionOrder.enteralFormula.additiveType",
"short": "Type of modular component to add to the feeding",
"definition": "Indicates the type of modular component such as protein, carbohydrate, fat or fiber to be provided in addition to or mixed with the base formula.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "EnteralFormulaAdditiveType"
}
],
"strength": "example",
"description": "Codes for the type of modular component such as protein, carbohydrate or fiber to be provided in addition to or mixed with the base formula.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/entformula-additive"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A (not differentiated from NutritionalFormulaType in HL7 v3)"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "NutritionOrder.enteralFormula.additiveProductName",
"path": "NutritionOrder.enteralFormula.additiveProductName",
"short": "Product or brand name of the modular additive",
"definition": "The product or brand name of the type of modular component to be added to the formula.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.enteralFormula.caloricDensity",
"path": "NutritionOrder.enteralFormula.caloricDensity",
"short": "Amount of energy per specified volume that is required",
"definition": "The amount of energy (calories) that the formula should provide per specified volume, typically per mL or fluid oz. For example, an infant may require a formula that provides 24 calories per fluid ounce or an adult may require an enteral formula that provides 1.5 calorie/mL.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".quantity (caloricDensity)"
}
]
},
{
"id": "NutritionOrder.enteralFormula.routeofAdministration",
"path": "NutritionOrder.enteralFormula.routeofAdministration",
"short": "How the formula should enter the patient's gastrointestinal tract",
"definition": "The route or physiological path of administration into the patient's gastrointestinal tract for purposes of providing the formula feeding, e.g. nasogastric tube.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "EnteralRouteOfAdministration"
}
],
"strength": "extensible",
"description": "Codes specifying the route of administration of enteral formula.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/enteral-route"
}
},
"mapping": [
{
"identity": "rim",
"map": ".routeCode"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administration",
"path": "NutritionOrder.enteralFormula.administration",
"short": "Formula feeding instruction as structured data",
"definition": "Formula administration instructions as structured data. This repeating structure allows for changing the administration rate or volume over time for both bolus and continuous feeding. An example of this would be an instruction to increase the rate of continuous feeding every 2 hours.",
"comment": "See implementation notes below for further discussion on how to order continuous vs bolus enteral feeding using this resource.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship [typeCode =COMP], target [classCode=SBADM, moodCode=RQO]"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administration.id",
"path": "NutritionOrder.enteralFormula.administration.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administration.extension",
"path": "NutritionOrder.enteralFormula.administration.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administration.modifierExtension",
"path": "NutritionOrder.enteralFormula.administration.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administration.schedule",
"path": "NutritionOrder.enteralFormula.administration.schedule",
"short": "Scheduled frequency of enteral feeding",
"definition": "The time period and frequency at which the enteral formula should be delivered to the patient.",
"alias": [
"Frequency"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Timing"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveUseTime"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administration.quantity",
"path": "NutritionOrder.enteralFormula.administration.quantity",
"short": "The volume of formula to provide",
"definition": "The volume of formula to provide to the patient per the specified administration schedule.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".doseQuantity"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administration.rate[x]",
"path": "NutritionOrder.enteralFormula.administration.rate[x]",
"short": "Speed with which the formula is provided per period of time",
"definition": "The rate of administration of formula via a feeding pump, e.g. 60 mL per hour, according to the specified schedule.",
"comment": "Ratio is used when the quantity value in the denominator is not \"1\", otherwise use Quantity. For example, the Ratio datatype is used for \"200 mL/4 hrs\" versus the Quantity datatype for \"50 mL/hr\".",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
},
{
"code": "Ratio"
}
],
"mapping": [
{
"identity": "rim",
"map": ".rateQuantity"
}
]
},
{
"id": "NutritionOrder.enteralFormula.maxVolumeToDeliver",
"path": "NutritionOrder.enteralFormula.maxVolumeToDeliver",
"short": "Upper limit on formula volume per unit of time",
"definition": "The maximum total quantity of formula that may be administered to a subject over the period of time, e.g. 1440 mL over 24 hours.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".maxDoseQuantity"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administrationInstruction",
"path": "NutritionOrder.enteralFormula.administrationInstruction",
"short": "Formula feeding instructions expressed as text",
"definition": "Free text formula administration, feeding instructions or additional instructions or information.",
"comment": "Free text dosage instructions can be used for cases where the instructions are too complex to code.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
}
]
},
"differential": {
"element": [
{
"id": "NutritionOrder",
"path": "NutritionOrder",
"short": "Diet, formula or nutritional supplement request",
"definition": "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident.",
"comment": "Referenced by an Order Request (workflow).",
"alias": [
"Nutrition Order",
"Diet Order",
"Diet",
"Nutritional Supplement",
"Enteral Nutrition"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "nor-1",
"severity": "warning",
"human": "Nutrition Order SHALL contain either Oral Diet , Supplement, or Enteral Formula class",
"expression": "oralDiet.exists() or supplement.exists() or enteralFormula.exists()",
"xpath": "exists(f:oralDiet) or exists(f:supplement) or exists(f:enteralFormula)"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "rim",
"map": "SupplyRequest"
},
{
"identity": "w5",
"map": "clinical.careprovision"
}
]
},
{
"id": "NutritionOrder.identifier",
"path": "NutritionOrder.identifier",
"short": "Identifiers assigned to this order",
"definition": "Identifiers assigned to this order by the order sender or by the order receiver.",
"comment": "The Identifier.type element can be to indicate filler vs. placer if needed. This is explained in further detail [here](procedurerequest.html#notes).",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "NutritionOrder.status",
"path": "NutritionOrder.status",
"short": "proposed | draft | planned | requested | active | on-hold | completed | cancelled | entered-in-error",
"definition": "The workflow status of the nutrition order/request.",
"comment": "Typically the system placing the order sets the status to \"requested\". Thereafter, the order is maintained by the receiver that updates the status as the request is handled.\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NutritionOrderStatus"
}
],
"strength": "required",
"description": "Codes specifying the state of the request. Describes the lifecycle of the nutrition order.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/nutrition-request-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "NutritionOrder.patient",
"path": "NutritionOrder.patient",
"short": "The person who requires the diet, formula or nutritional supplement",
"definition": "The person (patient) who needs the nutrition order for an oral diet, nutritional supplement and/or enteral or formula feeding.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.subject.reference(Patient)"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "NutritionOrder.encounter",
"path": "NutritionOrder.encounter",
"short": "The encounter associated with this nutrition order",
"definition": "An encounter that provides additional information about the healthcare context in which this request is made.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.context.reference(Encounter)"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "NutritionOrder.dateTime",
"path": "NutritionOrder.dateTime",
"short": "Date and time the nutrition order was requested",
"definition": "The date and time that this nutrition order was requested.",
"min": 1,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "rim",
"map": "author.time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "NutritionOrder.orderer",
"path": "NutritionOrder.orderer",
"short": "Who ordered the diet, formula or nutritional supplement",
"definition": "The practitioner that holds legal responsibility for ordering the diet, nutritional supplement, or formula feedings.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "NutritionOrder.allergyIntolerance",
"path": "NutritionOrder.allergyIntolerance",
"short": "List of the patient's food and nutrition-related allergies and intolerances",
"definition": "A link to a record of allergies or intolerances which should be included in the nutrition order.",
"comment": "Information on a patient's food allergies and intolerances to inform healthcare personnel about the type of foods that the patient shouldn't receive or consume.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/AllergyIntolerance"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON].target[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "NutritionOrder.foodPreferenceModifier",
"path": "NutritionOrder.foodPreferenceModifier",
"short": "Order-specific modifier about the type of food that should be given",
"definition": "This modifier is used to convey order-specific modifiers about the type of food that should be given. These can be derived from patient allergies, intolerances, or preferences such as Halal, Vegan or Kosher. This modifier applies to the entire nutrition order inclusive of the oral diet, nutritional supplements and enteral formula feedings.",
"comment": "Information on a patient's food preferences that inform healthcare personnel about the food that the patient should receive or consume.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PatientDiet"
}
],
"strength": "example",
"description": "Medical, cultural or ethical food preferences to help with catering requirements",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/encounter-diet"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship [typeCode =COMP], target [classCode=PROC, moodCode=EVN, code=NutritionModificationType]"
}
]
},
{
"id": "NutritionOrder.excludeFoodModifier",
"path": "NutritionOrder.excludeFoodModifier",
"short": "Order-specific modifier about the type of food that should not be given",
"definition": "This modifier is used to convey order-specific modifiers about the type of food that should NOT be given. These can be derived from patient allergies, intolerances, or preferences such as No Red Meat, No Soy or No Wheat or Gluten-Free. While it should not be necessary to repeat allergy or intolerance information captured in the referenced AllergyIntolerance resource in the excludeFoodModifier, this element may be used to convey additional specificity related to foods that should be eliminated from the patient’s diet for any reason. This modifier applies to the entire nutrition order inclusive of the oral diet, nutritional supplements and enteral formula feedings.",
"comment": "Information on a patient's food allergies, intolerances and preferences to inform healthcare personnel about the type of foods that the patient shouldn't receive or consume.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FoodType"
}
],
"strength": "example",
"description": "Codes used to indicate the type of food that should NOT be given to the patient.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/food-type"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.oralDiet",
"path": "NutritionOrder.oralDiet",
"short": "Oral diet components",
"definition": "Diet given orally in contrast to enteral (tube) feeding.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"nor-1"
],
"mapping": [
{
"identity": "rim",
"map": "oralDiet .outboundRelationship [typeCode =COMP], target [classCode=SPLY, moodCode=RQO, code=OralDietSupplyType]"
}
]
},
{
"id": "NutritionOrder.oralDiet.type",
"path": "NutritionOrder.oralDiet.type",
"short": "Type of oral diet or diet restrictions that describe what can be consumed orally",
"definition": "The kind of diet or dietary restriction such as fiber restricted diet or diabetic diet.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "OralDiet"
}
],
"strength": "example",
"description": "Codes used to indicate the type of diet being ordered for a patient.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/diet-type"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "NutritionOrder.oralDiet.schedule",
"path": "NutritionOrder.oralDiet.schedule",
"short": "Scheduled frequency of diet",
"definition": "The time period and frequency at which the diet should be given. The diet should be given for the combination of all schedules if more than one schedule is present.",
"alias": [
"Frequency"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Timing"
}
],
"mapping": [
{
"identity": "rim",
"map": ".expectedUseTime"
}
]
},
{
"id": "NutritionOrder.oralDiet.nutrient",
"path": "NutritionOrder.oralDiet.nutrient",
"short": "Required nutrient modifications",
"definition": "Class that defines the quantity and type of nutrient modifications (for example carbohydrate, fiber or sodium) required for the oral diet.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation{typeCode=PRD].role{classCode=MANU), manufacturedFoodKind"
}
]
},
{
"id": "NutritionOrder.oralDiet.nutrient.modifier",
"path": "NutritionOrder.oralDiet.nutrient.modifier",
"short": "Type of nutrient that is being modified",
"definition": "The nutrient that is being modified such as carbohydrate or sodium.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NutrientModifier"
}
],
"strength": "example",
"description": "Codes for types of nutrient that is being modified such as carbohydrate or sodium.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/nutrient-code"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "NutritionOrder.oralDiet.nutrient.amount",
"path": "NutritionOrder.oralDiet.nutrient.amount",
"short": "Quantity of the specified nutrient",
"definition": "The quantity of the specified nutrient to include in diet.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "NutritionOrder.oralDiet.texture",
"path": "NutritionOrder.oralDiet.texture",
"short": "Required texture modifications",
"definition": "Class that describes any texture modifications required for the patient to safely consume various types of solid foods.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship [typeCode =COMP], target [classCode=PROC, moodCode=EVN, code=DietTextureModificationType]"
}
]
},
{
"id": "NutritionOrder.oralDiet.texture.modifier",
"path": "NutritionOrder.oralDiet.texture.modifier",
"short": "Code to indicate how to alter the texture of the foods, e.g. pureed",
"definition": "Any texture modifications (for solid foods) that should be made, e.g. easy to chew, chopped, ground, and pureed.",
"comment": "Coupled with the foodType (Meat).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TextureModifier"
}
],
"strength": "example",
"description": "Codes for food consistency types or texture modifications to apply to foods.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/texture-code"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "NutritionOrder.oralDiet.texture.foodType",
"path": "NutritionOrder.oralDiet.texture.foodType",
"short": "Concepts that are used to identify an entity that is ingested for nutritional purposes",
"definition": "The food type(s) (e.g. meats, all foods) that the texture modification applies to. This could be all foods types.",
"comment": "Coupled with the textureModifier; could be (All Foods).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TextureModifiedFoodType"
}
],
"strength": "example",
"description": "Codes for types of foods that are texture modified.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/modified-foodtype"
}
},
"mapping": [
{
"identity": "rim",
"map": ".participation{typeCode=PRD].role{classCode=MANU), manufacturedFoodKind; .code"
}
]
},
{
"id": "NutritionOrder.oralDiet.fluidConsistencyType",
"path": "NutritionOrder.oralDiet.fluidConsistencyType",
"short": "The required consistency of fluids and liquids provided to the patient",
"definition": "The required consistency (e.g. honey-thick, nectar-thick, thin, thickened.) of liquids or fluids served to the patient.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FluidConsistencyType"
}
],
"strength": "example",
"description": "Codes used to represent the consistency of fluids and liquids provided to the patient.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/consistency-type"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code (Not differentiated from dietTextureModificationType in HL7 v3)"
}
]
},
{
"id": "NutritionOrder.oralDiet.instruction",
"path": "NutritionOrder.oralDiet.instruction",
"short": "Instructions or additional information about the oral diet",
"definition": "Free text or additional instructions or information pertaining to the oral diet.",
"comment": "Free text dosage instructions can be used for cases where the instructions are too complex to code.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "NutritionOrder.supplement",
"path": "NutritionOrder.supplement",
"short": "Supplement components",
"definition": "Oral nutritional products given in order to add further nutritional value to the patient's diet.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"nor-1"
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship [typeCode =COMP], target [classCode=SPLY, moodCode=RQO, code=SUPPLEMENT]"
}
]
},
{
"id": "NutritionOrder.supplement.type",
"path": "NutritionOrder.supplement.type",
"short": "Type of supplement product requested",
"definition": "The kind of nutritional supplement product required such as a high protein or pediatric clear liquid supplement.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplementType"
}
],
"strength": "example",
"description": "Codes for nutritional supplements to be provided to the patient",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplement-type"
}
},
"mapping": [
{
"identity": "rim",
"map": ".participation{typeCode=PRD].role{classCode=MANU), manufacturedFoodKind; .code (NutritionalSupplementType)"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "NutritionOrder.supplement.productName",
"path": "NutritionOrder.supplement.productName",
"short": "Product or brand name of the nutritional supplement",
"definition": "The product or brand name of the nutritional supplement such as \"Acme Protein Shake\".",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "NutritionOrder.supplement.schedule",
"path": "NutritionOrder.supplement.schedule",
"short": "Scheduled frequency of supplement",
"definition": "The time period and frequency at which the supplement(s) should be given. The supplement should be given for the combination of all schedules if more than one schedule is present.",
"alias": [
"Frequency"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Timing"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "NutritionOrder.supplement.quantity",
"path": "NutritionOrder.supplement.quantity",
"short": "Amount of the nutritional supplement",
"definition": "The amount of the nutritional supplement to be given.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "NutritionOrder.supplement.instruction",
"path": "NutritionOrder.supplement.instruction",
"short": "Instructions or additional information about the oral supplement",
"definition": "Free text or additional instructions or information pertaining to the oral supplement.",
"comment": "Free text dosage instructions can be used for cases where the instructions are too complex to code.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "NutritionOrder.enteralFormula",
"path": "NutritionOrder.enteralFormula",
"short": "Enteral formula components",
"definition": "Feeding provided through the gastrointestinal tract via a tube, catheter, or stoma that delivers nutrition distal to the oral cavity.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"nor-1"
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship [typeCode =COMP], target [classCode=SPLY, moodCode=RQO, code=FORMULA]"
}
]
},
{
"id": "NutritionOrder.enteralFormula.baseFormulaType",
"path": "NutritionOrder.enteralFormula.baseFormulaType",
"short": "Type of enteral or infant formula",
"definition": "The type of enteral or infant formula such as an adult standard formula with fiber or a soy-based infant formula.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "EnteralFormulaType"
}
],
"strength": "example",
"description": "Codes for type of enteral formula to be administered to patient.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/entformula-type"
}
},
"mapping": [
{
"identity": "rim",
"map": ".participation{typeCode=PRD].role{classCode=MANU), manufacturedFoodKind; .code (NutritionalFormulaType)"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "NutritionOrder.enteralFormula.baseFormulaProductName",
"path": "NutritionOrder.enteralFormula.baseFormulaProductName",
"short": "Product or brand name of the enteral or infant formula",
"definition": "The product or brand name of the enteral or infant formula product such as \"ACME Adult Standard Formula\".",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "NutritionOrder.enteralFormula.additiveType",
"path": "NutritionOrder.enteralFormula.additiveType",
"short": "Type of modular component to add to the feeding",
"definition": "Indicates the type of modular component such as protein, carbohydrate, fat or fiber to be provided in addition to or mixed with the base formula.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "EnteralFormulaAdditiveType"
}
],
"strength": "example",
"description": "Codes for the type of modular component such as protein, carbohydrate or fiber to be provided in addition to or mixed with the base formula.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/entformula-additive"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A (not differentiated from NutritionalFormulaType in HL7 v3)"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "NutritionOrder.enteralFormula.additiveProductName",
"path": "NutritionOrder.enteralFormula.additiveProductName",
"short": "Product or brand name of the modular additive",
"definition": "The product or brand name of the type of modular component to be added to the formula.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "NutritionOrder.enteralFormula.caloricDensity",
"path": "NutritionOrder.enteralFormula.caloricDensity",
"short": "Amount of energy per specified volume that is required",
"definition": "The amount of energy (calories) that the formula should provide per specified volume, typically per mL or fluid oz. For example, an infant may require a formula that provides 24 calories per fluid ounce or an adult may require an enteral formula that provides 1.5 calorie/mL.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".quantity (caloricDensity)"
}
]
},
{
"id": "NutritionOrder.enteralFormula.routeofAdministration",
"path": "NutritionOrder.enteralFormula.routeofAdministration",
"short": "How the formula should enter the patient's gastrointestinal tract",
"definition": "The route or physiological path of administration into the patient's gastrointestinal tract for purposes of providing the formula feeding, e.g. nasogastric tube.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "EnteralRouteOfAdministration"
}
],
"strength": "extensible",
"description": "Codes specifying the route of administration of enteral formula.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/enteral-route"
}
},
"mapping": [
{
"identity": "rim",
"map": ".routeCode"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administration",
"path": "NutritionOrder.enteralFormula.administration",
"short": "Formula feeding instruction as structured data",
"definition": "Formula administration instructions as structured data. This repeating structure allows for changing the administration rate or volume over time for both bolus and continuous feeding. An example of this would be an instruction to increase the rate of continuous feeding every 2 hours.",
"comment": "See implementation notes below for further discussion on how to order continuous vs bolus enteral feeding using this resource.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship [typeCode =COMP], target [classCode=SBADM, moodCode=RQO]"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administration.schedule",
"path": "NutritionOrder.enteralFormula.administration.schedule",
"short": "Scheduled frequency of enteral feeding",
"definition": "The time period and frequency at which the enteral formula should be delivered to the patient.",
"alias": [
"Frequency"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Timing"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveUseTime"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administration.quantity",
"path": "NutritionOrder.enteralFormula.administration.quantity",
"short": "The volume of formula to provide",
"definition": "The volume of formula to provide to the patient per the specified administration schedule.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".doseQuantity"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administration.rate[x]",
"path": "NutritionOrder.enteralFormula.administration.rate[x]",
"short": "Speed with which the formula is provided per period of time",
"definition": "The rate of administration of formula via a feeding pump, e.g. 60 mL per hour, according to the specified schedule.",
"comment": "Ratio is used when the quantity value in the denominator is not \"1\", otherwise use Quantity. For example, the Ratio datatype is used for \"200 mL/4 hrs\" versus the Quantity datatype for \"50 mL/hr\".",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
},
{
"code": "Ratio"
}
],
"mapping": [
{
"identity": "rim",
"map": ".rateQuantity"
}
]
},
{
"id": "NutritionOrder.enteralFormula.maxVolumeToDeliver",
"path": "NutritionOrder.enteralFormula.maxVolumeToDeliver",
"short": "Upper limit on formula volume per unit of time",
"definition": "The maximum total quantity of formula that may be administered to a subject over the period of time, e.g. 1440 mL over 24 hours.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".maxDoseQuantity"
}
]
},
{
"id": "NutritionOrder.enteralFormula.administrationInstruction",
"path": "NutritionOrder.enteralFormula.administrationInstruction",
"short": "Formula feeding instructions expressed as text",
"definition": "Free text formula administration, feeding instructions or additional instructions or information.",
"comment": "Free text dosage instructions can be used for cases where the instructions are too complex to code.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Observation",
"resource": {
"resourceType": "StructureDefinition",
"id": "Observation",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Observation I DomainResource Measurements and simple assertions
+ If code is the same as a component code then the value element associated with the code SHALL NOT be present
+ dataAbsentReason SHALL only be present if Observation.value[x] is not present
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier Business Identifier for observation
basedOn Σ 0..* Reference(CarePlan | DeviceRequest | ImmunizationRecommendation | MedicationRequest | NutritionOrder | ProcedureRequest | ReferralRequest) Fulfills plan, proposal or order
status ?!Σ 1..1 code registered | preliminary | final | amended +
ObservationStatus (Required) category 0..* CodeableConcept Classification of type of observation
Observation Category Codes (Preferred)
code Σ 1..1 CodeableConcept Type of observation (code / type)
LOINC Codes (Example) subject Σ 0..1 Reference(Patient | Group | Device | Location) Who and/or what this is about context 0..1 Reference(Encounter | EpisodeOfCare) Healthcare event during which this observation is made effective[x] Σ 0..1 Clinically relevant time/time-period for observation effectiveDateTime dateTime effectivePeriod Period issued Σ 0..1 instant Date/Time this was made available performer Σ 0..* Reference(Practitioner | Organization | Patient | RelatedPerson) Who is responsible for the observation
value[x] ΣI 0..1 Actual result valueQuantity Quantity valueCodeableConcept CodeableConcept valueString string valueBoolean boolean valueRange Range valueRatio Ratio valueSampledData SampledData valueAttachment Attachment valueTime time valueDateTime dateTime valuePeriod Period dataAbsentReason I 0..1 CodeableConcept Why the result is missing
Observation Value Absent Reason (Extensible) interpretation 0..1 CodeableConcept High, low, normal, etc.
Observation Interpretation Codes (Extensible) comment 0..1 string Comments about result bodySite 0..1 CodeableConcept Observed body part
SNOMED CT Body Structures (Example) method 0..1 CodeableConcept How it was done
Observation Methods (Example) specimen 0..1 Reference(Specimen) Specimen used for this observation device 0..1 Reference(Device | DeviceMetric) (Measurement) Device referenceRange I 0..* BackboneElement Provides guide for interpretation
+ Must have at least a low or a high or text
low I 0..1 SimpleQuantity Low Range, if relevant high I 0..1 SimpleQuantity High Range, if relevant type 0..1 CodeableConcept Reference range qualifier
Observation Reference Range Meaning Codes (Extensible) appliesTo 0..* CodeableConcept Reference range population
Observation Reference Range Applies To Codes (Example)
age 0..1 Range Applicable age range, if relevant text 0..1 string Text based reference range in an observation related Σ 0..* BackboneElement Resource related to this observation
type 0..1 code has-member | derived-from | sequel-to | replaces | qualified-by | interfered-by
ObservationRelationshipType (Required) target 1..1 Reference(Observation | QuestionnaireResponse | Sequence) Resource that is related to this one component Σ 0..* BackboneElement Component results
code Σ 1..1 CodeableConcept Type of component observation (code / type)
LOINC Codes (Example) value[x] Σ 0..1 Actual component result valueQuantity Quantity valueCodeableConcept CodeableConcept valueString string valueRange Range valueRatio Ratio valueSampledData SampledData valueAttachment Attachment valueTime time valueDateTime dateTime valuePeriod Period dataAbsentReason I 0..1 CodeableConcept Why the component result is missing
Observation Value Absent Reason (Extensible) interpretation 0..1 CodeableConcept High, low, normal, etc.
Observation Interpretation Codes (Extensible) referenceRange 0..* see referenceRange Provides guide for interpretation of component result
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 5
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "oo"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Observation",
"name": "Observation",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Orders and Observations)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/orders/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Observation Resource",
"purpose": "Observations are a key aspect of healthcare. This resource is used to capture those that do not require more sophisticated mechanisms.",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "sct-concept",
"uri": "http://snomed.info/conceptdomain",
"name": "SNOMED CT Concept Domain Binding"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "sct-attr",
"uri": "http://snomed.info/sct",
"name": "SNOMED CT Attribute Binding"
}
],
"kind": "resource",
"abstract": false,
"type": "Observation",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Observation",
"path": "Observation",
"short": "Measurements and simple assertions",
"definition": "Measurements and simple assertions made about a patient, device or other subject.",
"comment": "Used for simple observations such as device measurements, laboratory atomic results, vital signs, height, weight, smoking status, comments, etc. Other resources are used to provide context for observations such as lab reports, etc.",
"alias": [
"Vital Signs",
"Measurement",
"Results",
"Tests"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "obs-7",
"severity": "error",
"human": "If code is the same as a component code then the value element associated with the code SHALL NOT be present",
"expression": "value.empty() or code!=component.code",
"xpath": "not(exists(f:*[starts-with(local-name(.), 'value')])) or not(count(for $coding in f:code/f:coding return parent::*/f:component/f:code/f:coding[f:code/@value=$coding/f:code/@value and f:system/@value=$coding/f:system/@value])=0)"
},
{
"key": "obs-6",
"severity": "error",
"human": "dataAbsentReason SHALL only be present if Observation.value[x] is not present",
"expression": "dataAbsentReason.empty() or value.empty()",
"xpath": "not(exists(f:dataAbsentReason)) or (not(exists(*[starts-with(local-name(.), 'value')])))"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "sct-concept",
"map": "< 363787002 |Observable entity|"
},
{
"identity": "v2",
"map": "OBX"
},
{
"identity": "rim",
"map": "Observation[classCode=OBS, moodCode=EVN]"
},
{
"identity": "w5",
"map": "clinical.diagnostics"
}
]
},
{
"id": "Observation.id",
"path": "Observation.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Observation.meta",
"path": "Observation.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Observation.implicitRules",
"path": "Observation.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Observation.language",
"path": "Observation.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Observation.text",
"path": "Observation.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Observation.contained",
"path": "Observation.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Observation.extension",
"path": "Observation.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Observation.modifierExtension",
"path": "Observation.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Observation.identifier",
"path": "Observation.identifier",
"short": "Business Identifier for observation",
"definition": "A unique identifier assigned to this observation.",
"requirements": "Allows observations to be distinguished and referenced.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "v2",
"map": "OBX.21 For OBX segments from systems without OBX-21 support a combination of ORC/OBR and OBX must be negotiated between trading partners to uniquely identify the OBX segment. Depending on how V2 has been implemented each of these may be an option: 1) OBR-3 + OBX-3 + OBX-4 or 2) OBR-3 + OBR-4 + OBX-3 + OBX-4 or 2) some other way to uniquely ID the OBR/ORC + OBX-3 + OBX-4."
},
{
"identity": "rim",
"map": "id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Observation.basedOn",
"path": "Observation.basedOn",
"short": "Fulfills plan, proposal or order",
"definition": "A plan, proposal or order that is fulfilled in whole or in part by this event.",
"requirements": "Allows tracing of authorization for the event and tracking whether proposals/recommendations were acted upon.",
"alias": [
"Fulfills"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DeviceRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ImmunizationRecommendation"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/NutritionOrder"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.basedOn"
},
{
"identity": "v2",
"map": "ORC"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target"
}
]
},
{
"id": "Observation.status",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-display-hint",
"valueString": "default: final"
}
],
"path": "Observation.status",
"short": "registered | preliminary | final | amended +",
"definition": "The status of the result value.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"requirements": "Need to track the status of individual results. Some results are finalized before the whole report is finalized.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationStatus"
}
],
"strength": "required",
"description": "Codes providing the status of an observation.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "sct-concept",
"map": "< 445584004 |Report by finality status|"
},
{
"identity": "v2",
"map": "OBX-11"
},
{
"identity": "rim",
"map": "status Amended & Final are differentiated by whether it is the subject of a ControlAct event with a type of \"revise\""
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Observation.category",
"path": "Observation.category",
"short": "Classification of type of observation",
"definition": "A code that classifies the general type of observation being made.",
"comment": "In addition to the required category valueset, this element allows various categorization schemes based on the owner’s definition of the category and effectively multiple categories can be used at once. The level of granularity is defined by the category concepts in the value set.",
"requirements": "Used for filtering what observations are retrieved and displayed.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationCategory"
}
],
"strength": "preferred",
"description": "Codes for high level observation categories.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"LIST\", moodCode=\"EVN\"].code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Observation.code",
"path": "Observation.code",
"short": "Type of observation (code / type)",
"definition": "Describes what was observed. Sometimes this is called the observation \"name\".",
"requirements": "Knowing what kind of observation is being made is essential to understanding the observation.",
"alias": [
"Name"
],
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationCode"
}
],
"strength": "example",
"description": "Codes identifying names of simple observations.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.code"
},
{
"identity": "sct-concept",
"map": "< 363787002 |Observable entity| OR < 386053000 |Evaluation procedure|"
},
{
"identity": "v2",
"map": "OBX-3"
},
{
"identity": "rim",
"map": "code"
},
{
"identity": "sct-attr",
"map": "116680003 |Is a|"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Observation.subject",
"path": "Observation.subject",
"short": "Who and/or what this is about",
"definition": "The patient, or group of patients, location, or device whose characteristics (direct or indirect) are described by the observation and into whose record the observation is placed. Comments: Indirect characteristics may be those of a specimen, fetus, donor, other observer (for example a relative or EMT), or any observation made about the subject.",
"comment": "One would expect this element to be a cardinality of 1..1. The only circumstance in which the subject can be missing is when the observation is made by a device that does not know the patient. In this case, the observation SHALL be matched to a patient through some context/channel matching technique, and at this point, the observation should be updated.\r\rIf the target of the observation is different than the subject, the general extension [observation-focal-subject](extension-observation-focal-subject.html). may be used. However, the distinction between the patient's own value for an observation versus that of the fetus, or the donor or blood product unit, etc., are often specified in the observation code.",
"requirements": "Observations have no value if you don't know who or what they're about.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.subject"
},
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "rim",
"map": "participation[typeCode=SBJ]"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Observation.context",
"path": "Observation.context",
"short": "Healthcare event during which this observation is made",
"definition": "The healthcare event (e.g. a patient and healthcare provider interaction) during which this observation is made.",
"comment": "This will typically be the encounter the event occurred within, but some events may be initiated prior to or after the official completion of an encounter or episode but still be tied to the context of the encounter or episode (e.g. pre-admission lab tests).",
"requirements": "For some observations it may be important to know the link between an observation and a particular encounter.",
"alias": [
"Encounter"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.context"
},
{
"identity": "v2",
"map": "PV1"
},
{
"identity": "rim",
"map": "inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "Observation.effective[x]",
"path": "Observation.effective[x]",
"short": "Clinically relevant time/time-period for observation",
"definition": "The time or time-period the observed value is asserted as being true. For biological subjects - e.g. human patients - this is usually called the \"physiologically relevant time\". This is usually either the time of the procedure or of specimen collection, but very often the source of the date/time is not known, only the date/time itself.",
"comment": "At least a date should be present unless this observation is a historical report.",
"requirements": "Knowing when an observation was deemed true is important to its relevance as well as determining trends.",
"alias": [
"Occurrence"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence[x]"
},
{
"identity": "v2",
"map": "OBX-14, and/or OBX-19 after v2.4 (depends on who observation made)"
},
{
"identity": "rim",
"map": "effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Observation.issued",
"path": "Observation.issued",
"short": "Date/Time this was made available",
"definition": "The date and time this observation was made available to providers, typically after the results have been reviewed and verified.",
"comment": "Updated when the result is updated.",
"min": 0,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "OBR.22 (or MSH.7), or perhaps OBX-19 (depends on who observation made)"
},
{
"identity": "rim",
"map": "participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "Observation.performer",
"path": "Observation.performer",
"short": "Who is responsible for the observation",
"definition": "Who was responsible for asserting the observed value as \"true\".",
"requirements": "May give a degree of confidence in the observation and also indicates where follow-up questions should be directed.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.performer"
},
{
"identity": "v2",
"map": "OBX.15 / (Practitioner) OBX-16, PRT-5:PRT-4='RO' / (Device) OBX-18 , PRT-10:PRT-4='EQUIP' / (Organization) OBX-23, PRT-8:PRT-4='PO'"
},
{
"identity": "rim",
"map": "participation[typeCode=PRF]"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Observation.value[x]",
"path": "Observation.value[x]",
"short": "Actual result",
"definition": "The information determined as a result of making the observation, if the information has a simple value.",
"comment": "Normally, an observation will have either a single value or a set of related observations. A few observations (e.g. Apgar score) may have both a value and related observations (for an Apgar score, the observations from which the measure is derived). If a value is present, the datatype for this element should be determined by Observation.code. This element has a variable name depending on the type as follows: valueQuantity, valueCodeableConcept, valueString, valueBoolean, valueRange, valueRatio, valueSampledData, valueAttachment, valueTime, valueDateTime, or valuePeriod. (The name format is \"'value' + the type name\" with a capital on the first letter of the type).\r\r\rIf the data element is usually coded or if the type associated with the Observation.value defines a coded value, use CodeableConcept instead of string datatype even if the value is uncoded text. A value set is bound to the ValueCodeableConcept element. For further discussion and examples see the [notes section](observation.html#notes) below.",
"requirements": "An observation exists to have a value, though it may not if it is in error, or if it represents a group of observations.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity"
},
{
"code": "CodeableConcept"
},
{
"code": "string"
},
{
"code": "boolean"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "SampledData"
},
{
"code": "Attachment"
},
{
"code": "time"
},
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"condition": [
"obs-7"
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.notDone, Event.notDoneReason (maps to valeu[x] or dataAbsentReason)"
},
{
"identity": "sct-concept",
"map": "< 441742003 |Evaluation finding|"
},
{
"identity": "v2",
"map": "OBX.2, OBX.5, OBX.6"
},
{
"identity": "rim",
"map": "value"
},
{
"identity": "sct-attr",
"map": "363714003 |Interprets|"
}
]
},
{
"id": "Observation.dataAbsentReason",
"path": "Observation.dataAbsentReason",
"short": "Why the result is missing",
"definition": "Provides a reason why the expected value in the element Observation.value[x] is missing.",
"comment": "Null or exceptional values can be represented two ways in FHIR Observations. One way is to simply include them in the value set and represent the exceptions in the value. For example, measurement values for a serology test could be \"detected\", \"not detected\", \"inconclusive\", or \"specimen unsatisfactory\". The alternate way is to use the value element for actual observations and use the explicit dataAbsentReason element to record exceptional values. For example, the dataAbsentReason code \"error\" could be used when the measurement was not completed. Note that an observation may only be reported if there are values to report. For example differential cell counts values may be reported only when > 0. Because of these options, use-case agreements are required to interpret general observations for null or exceptional values.",
"requirements": "For many results it is necessary to handle exceptional values in measurements.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"obs-6"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationValueAbsentReason"
}
],
"strength": "extensible",
"description": "Codes specifying why the result (Observation.value[x]) is missing.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-valueabsentreason"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.notDone, Event.notDoneReason (maps to valeu[x] or dataAbsentReason)"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "value.nullFlavor"
}
]
},
{
"id": "Observation.interpretation",
"path": "Observation.interpretation",
"short": "High, low, normal, etc.",
"definition": "The assessment made based on the result of the observation. Intended as a simple compact code often placed adjacent to the result value in reports and flow sheets to signal the meaning/normalcy status of the result. Otherwise known as abnormal flag.",
"requirements": "For some results, particularly numeric results, an interpretation is necessary to fully understand the significance of a result.",
"alias": [
"Abnormal Flag"
],
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationInterpretation"
}
],
"strength": "extensible",
"description": "Codes identifying interpretations of observations.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-interpretation"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 260245000 |Findings values|"
},
{
"identity": "v2",
"map": "OBX-8"
},
{
"identity": "rim",
"map": "interpretationCode"
},
{
"identity": "sct-attr",
"map": "363713009 |Has interpretation|"
}
]
},
{
"id": "Observation.comment",
"path": "Observation.comment",
"short": "Comments about result",
"definition": "May include statements about significant, unexpected or unreliable values, or information about the source of the value where this may be relevant to the interpretation of the result.",
"requirements": "Need to be able to provide free text additional information.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.note"
},
{
"identity": "v2",
"map": "NTE.3 (partner NTE to OBX, or sometimes another (child?) OBX)"
},
{
"identity": "rim",
"map": "subjectOf.observationEvent[code=\"annotation\"].value"
}
]
},
{
"id": "Observation.bodySite",
"path": "Observation.bodySite",
"short": "Observed body part",
"definition": "Indicates the site on the subject's body where the observation was made (i.e. the target site).",
"comment": "Only used if not implicit in code found in Observation.code. In many systems, this may be represented as a related observation instead of an inline component. If the use case requires BodySite to be handled as a separate resource (e.g. to identify and track separately) then use the standard extension[ body-site-instance](extension-body-site-instance.html).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "BodySite"
}
],
"strength": "example",
"description": "Codes describing anatomical locations. May include laterality.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/body-site"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 123037004 |Body structure|"
},
{
"identity": "v2",
"map": "OBX-20"
},
{
"identity": "rim",
"map": "targetSiteCode"
},
{
"identity": "sct-attr",
"map": "718497002 |Inherent location|"
}
]
},
{
"id": "Observation.method",
"path": "Observation.method",
"short": "How it was done",
"definition": "Indicates the mechanism used to perform the observation.",
"comment": "Only used if not implicit in code for Observation.code.",
"requirements": "In some cases, method can impact results and is thus used for determining whether results can be compared or determining significance of results.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationMethod"
}
],
"strength": "example",
"description": "Methods for simple observations.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-methods"
}
},
"mapping": [
{
"identity": "v2",
"map": "OBX-17"
},
{
"identity": "rim",
"map": "methodCode"
}
]
},
{
"id": "Observation.specimen",
"path": "Observation.specimen",
"short": "Specimen used for this observation",
"definition": "The specimen that was used when this observation was made.",
"comment": "Should only be used if not implicit in code found in `Observation.code`. Observations are not made on specimens themselves; they are made on a subject, but in many cases by the means of a specimen. Note that although specimens are often involved, they are not always tracked and reported explicitly. Also note that observation resources may be used in contexts that track the specimen explicitly (e.g. Diagnostic Report).",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Specimen"
}
],
"mapping": [
{
"identity": "sct-concept",
"map": "< 123038009 |Specimen|"
},
{
"identity": "v2",
"map": "SPM segment"
},
{
"identity": "rim",
"map": "participation[typeCode=SPC].specimen"
},
{
"identity": "sct-attr",
"map": "704319004 |Inherent in|"
}
]
},
{
"id": "Observation.device",
"path": "Observation.device",
"short": "(Measurement) Device",
"definition": "The device used to generate the observation data.",
"comment": "An extension should be used if further typing of the device is needed. Devices used to support obtaining an observation can be represented using either an extension or through the Observation.related element.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DeviceMetric"
}
],
"mapping": [
{
"identity": "sct-concept",
"map": "< 49062001 |Device|"
},
{
"identity": "v2",
"map": "OBX-17 / PRT -10"
},
{
"identity": "rim",
"map": "participation[typeCode=DEV]"
},
{
"identity": "sct-attr",
"map": "424226004 |Using device|"
}
]
},
{
"id": "Observation.referenceRange",
"path": "Observation.referenceRange",
"short": "Provides guide for interpretation",
"definition": "Guidance on how to interpret the value by comparison to a normal or recommended range.",
"comment": "Most observations only have one generic reference range. Systems MAY choose to restrict to only supplying the relevant reference range based on knowledge about the patient (e.g., specific to the patient's age, gender, weight and other factors), but this may not be possible or appropriate. Whenever more than one reference range is supplied, the differences between them SHOULD be provided in the reference range and/or age properties.",
"requirements": "Knowing what values are considered \"normal\" can help evaluate the significance of a particular result. Need to be able to provide multiple reference ranges for different contexts.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "obs-3",
"severity": "error",
"human": "Must have at least a low or a high or text",
"expression": "low.exists() or high.exists() or text.exists()",
"xpath": "(exists(f:low) or exists(f:high)or exists(f:text))"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX.7"
},
{
"identity": "rim",
"map": "outboundRelationship[typeCode=REFV]/target[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "Observation.referenceRange.id",
"path": "Observation.referenceRange.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Observation.referenceRange.extension",
"path": "Observation.referenceRange.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Observation.referenceRange.modifierExtension",
"path": "Observation.referenceRange.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Observation.referenceRange.low",
"path": "Observation.referenceRange.low",
"short": "Low Range, if relevant",
"definition": "The value of the low bound of the reference range. The low bound of the reference range endpoint is inclusive of the value (e.g. reference range is >=5 - <=9). If the low bound is omitted, it is assumed to be meaningless (e.g. reference range is <=2.3).",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"condition": [
"obs-3"
],
"mapping": [
{
"identity": "v2",
"map": "OBX-7"
},
{
"identity": "rim",
"map": "value:IVL_PQ.low"
}
]
},
{
"id": "Observation.referenceRange.high",
"path": "Observation.referenceRange.high",
"short": "High Range, if relevant",
"definition": "The value of the high bound of the reference range. The high bound of the reference range endpoint is inclusive of the value (e.g. reference range is >=5 - <=9). If the high bound is omitted, it is assumed to be meaningless (e.g. reference range is >= 2.3).",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"condition": [
"obs-3"
],
"mapping": [
{
"identity": "v2",
"map": "OBX-7"
},
{
"identity": "rim",
"map": "value:IVL_PQ.high"
}
]
},
{
"id": "Observation.referenceRange.type",
"path": "Observation.referenceRange.type",
"short": "Reference range qualifier",
"definition": "Codes to indicate the what part of the targeted reference population it applies to. For example, the normal or therapeutic range.",
"comment": "This SHOULD be populated if there is more than one range. If this element is not present then the normal range is assumed.",
"requirements": "Need to be able to say what kind of reference range this is - normal, recommended, therapeutic, etc, - for proper interpretation.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationRangeMeaning"
}
],
"strength": "extensible",
"description": "Code for the meaning of a reference range.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/referencerange-meaning"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 260245000 |Findings values| OR \r< 365860008 |General clinical state finding| \rOR \r< 250171008 |Clinical history or observation findings| OR \r< 415229000 |Racial group| OR \r< 365400002 |Finding of puberty stage| OR\r< 443938003 |Procedure carried out on subject|"
},
{
"identity": "v2",
"map": "OBX-10"
},
{
"identity": "rim",
"map": "interpretationCode"
}
]
},
{
"id": "Observation.referenceRange.appliesTo",
"path": "Observation.referenceRange.appliesTo",
"short": "Reference range population",
"definition": "Codes to indicate the target population this reference range applies to. For example, a reference range may be based on the normal population or a particular sex or race.",
"comment": "This SHOULD be populated if there is more than one range. If this element is not present then the normal population is assumed.",
"requirements": "Need to be able to identify the target population for proper interpretation.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationRangeType"
}
],
"strength": "example",
"description": "Codes identifying the population the reference range applies to.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/referencerange-appliesto"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 260245000 |Findings values| OR \r< 365860008 |General clinical state finding| \rOR \r< 250171008 |Clinical history or observation findings| OR \r< 415229000 |Racial group| OR \r< 365400002 |Finding of puberty stage| OR\r< 443938003 |Procedure carried out on subject|"
},
{
"identity": "v2",
"map": "OBX-10"
},
{
"identity": "rim",
"map": "interpretationCode"
}
]
},
{
"id": "Observation.referenceRange.age",
"path": "Observation.referenceRange.age",
"short": "Applicable age range, if relevant",
"definition": "The age at which this reference range is applicable. This is a neonatal age (e.g. number of weeks at term) if the meaning says so.",
"requirements": "Some analytes vary greatly over age.",
"min": 0,
"max": "1",
"type": [
{
"code": "Range"
}
],
"mapping": [
{
"identity": "rim",
"map": "outboundRelationship[typeCode=PRCN].targetObservationCriterion[code=\"age\"].value"
}
]
},
{
"id": "Observation.referenceRange.text",
"path": "Observation.referenceRange.text",
"short": "Text based reference range in an observation",
"definition": "Text based reference range in an observation which may be used when a quantitative range is not appropriate for an observation. An example would be a reference value of \"Negative\" or a list or table of 'normals'.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX-7"
},
{
"identity": "rim",
"map": "value:ST"
}
]
},
{
"id": "Observation.related",
"path": "Observation.related",
"short": "Resource related to this observation",
"definition": "A reference to another resource (usually another Observation) whose relationship is defined by the relationship type code.",
"comment": "For a discussion on the ways Observations can assembled in groups together see [Notes below](observation.html#4.20.4).",
"requirements": "Normally, an observation will have either a value or a set of related observations. A few observations (e.g. Apgar score) may have both a value and a set of related observations or sometimes a QuestionnaireResponse from which the measure is derived.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "Relationships established by OBX-4 usage"
},
{
"identity": "rim",
"map": "outBoundRelationship"
}
]
},
{
"id": "Observation.related.id",
"path": "Observation.related.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Observation.related.extension",
"path": "Observation.related.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Observation.related.modifierExtension",
"path": "Observation.related.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Observation.related.type",
"path": "Observation.related.type",
"short": "has-member | derived-from | sequel-to | replaces | qualified-by | interfered-by",
"definition": "A code specifying the kind of relationship that exists with the target resource.",
"comment": "The \"derived-from\" type is the only logical choice when referencing the QuestionnaireAnswer resource.",
"requirements": "A relationship type SHOULD be provided.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationRelationshipType"
}
],
"strength": "required",
"description": "Codes specifying how two observations are related.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-relationshiptypes"
}
},
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".typeCode"
}
]
},
{
"id": "Observation.related.target",
"path": "Observation.related.target",
"short": "Resource that is related to this one",
"definition": "A reference to the observation or [QuestionnaireResponse](questionnaireresponse.html#) resource that is related to this observation.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/QuestionnaireResponse"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Sequence"
}
],
"mapping": [
{
"identity": "rim",
"map": ".targetObservation"
}
]
},
{
"id": "Observation.component",
"path": "Observation.component",
"short": "Component results",
"definition": "Some observations have multiple component observations. These component observations are expressed as separate code value pairs that share the same attributes. Examples include systolic and diastolic component observations for blood pressure measurement and multiple component observations for genetics observations.",
"comment": "For a discussion on the ways Observations can be assembled in groups together see [Notes](observation.html#notes) below.",
"requirements": "Component observations share the same attributes in the Observation resource as the primary observation and are always treated a part of a single observation (they are not separable). However, the reference range for the primary observation value is not inherited by the component values and is required when appropriate for each component observation.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "containment by OBX-4?"
},
{
"identity": "rim",
"map": "outBoundRelationship[typeCode=COMP]"
}
]
},
{
"id": "Observation.component.id",
"path": "Observation.component.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Observation.component.extension",
"path": "Observation.component.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Observation.component.modifierExtension",
"path": "Observation.component.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Observation.component.code",
"path": "Observation.component.code",
"short": "Type of component observation (code / type)",
"definition": "Describes what was observed. Sometimes this is called the observation \"code\".",
"requirements": "Knowing what kind of observation is being made is essential to understanding the observation.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationCode"
}
],
"strength": "example",
"description": "Codes identifying names of simple observations.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-codes"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 363787002 |Observable entity| OR \r< 386053000 |Evaluation procedure|"
},
{
"identity": "v2",
"map": "OBX-3"
},
{
"identity": "rim",
"map": "code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Observation.component.value[x]",
"path": "Observation.component.value[x]",
"short": "Actual component result",
"definition": "The information determined as a result of making the observation, if the information has a simple value.",
"comment": "Normally, an observation will have either a single value or a set of related observations. A few observations (e.g. Apgar score) may have both a value and related observations (for an Apgar score, the observations from which the measure is derived). If a value is present, the datatype for this element should be determined by Observation.code. A CodeableConcept with just a text would be used instead of a string if the field was usually coded, or if the type associated with the Observation.code defines a coded value. For boolean values use valueCodeableConcept and select codes from (these \"yes/no\" concepts can be mapped to the display name \"true/false\" or other mutually exclusive terms that may be needed\"). The element, Observation.value[x], has a variable name depending on the type as follows: valueQuantity, valueCodeableConcept, valueRatio, valueChoice, valuePeriod, valueSampleData, or valueString (the name format is \"'value' + the type name\" with a capital on the first letter of the type).",
"requirements": "An observation exists to have a value, though it may not if it is in error, or if it represents a group of observations.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity"
},
{
"code": "CodeableConcept"
},
{
"code": "string"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "SampledData"
},
{
"code": "Attachment"
},
{
"code": "time"
},
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "sct-concept",
"map": "363714003 |Interprets| < 441742003 |Evaluation finding|"
},
{
"identity": "v2",
"map": "OBX.2, OBX.5, OBX.6"
},
{
"identity": "rim",
"map": "value"
},
{
"identity": "sct-attr",
"map": "363714003 |Interprets|"
}
]
},
{
"id": "Observation.component.dataAbsentReason",
"path": "Observation.component.dataAbsentReason",
"short": "Why the component result is missing",
"definition": "Provides a reason why the expected value in the element Observation.value[x] is missing.",
"comment": "\"Null\" or exceptional values can be represented two ways in FHIR Observations. One way is to simply include them in the value set and represent the exceptions in the value. For example, measurement values for a serology test could be \"detected\", \"not detected\", \"inconclusive\", or \"test not done\". The alternate way is to use the value element for actual observations and use the explicit dataAbsentReason element to record exceptional values. For example, the dataAbsentReason code \"error\" could be used when the measurement was not completed. Because of these options, use-case agreements are required to interpret general observations for exceptional values.",
"requirements": "For many results it is necessary to handle exceptional values in measurements.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"obs-6"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationValueAbsentReason"
}
],
"strength": "extensible",
"description": "Codes specifying why the result (Observation.value[x]) is missing.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-valueabsentreason"
}
},
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "value.nullFlavor"
}
]
},
{
"id": "Observation.component.interpretation",
"path": "Observation.component.interpretation",
"short": "High, low, normal, etc.",
"definition": "The assessment made based on the result of the observation. Intended as a simple compact code often placed adjacent to the result value in reports and flow sheets to signal the meaning/normalcy status of the result. Otherwise known as abnormal flag.",
"comment": "The component interpretation applies only to the individual component value. For an overall interpretation all components together use thes Observation.interpretation element.",
"requirements": "For some results, particularly numeric results, an interpretation is necessary to fully understand the significance of a result.",
"alias": [
"Abnormal Flag"
],
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationInterpretation"
}
],
"strength": "extensible",
"description": "Codes identifying interpretations of observations.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-interpretation"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 260245000 |Findings values|"
},
{
"identity": "v2",
"map": "OBX-8"
},
{
"identity": "rim",
"map": "interpretationCode"
},
{
"identity": "sct-attr",
"map": "363713009 |Has interpretation|"
}
]
},
{
"id": "Observation.component.referenceRange",
"path": "Observation.component.referenceRange",
"short": "Provides guide for interpretation of component result",
"definition": "Guidance on how to interpret the value by comparison to a normal or recommended range.",
"comment": "Most observations only have one generic reference range. Systems MAY choose to restrict to only supplying the relevant reference range based on knowledge about the patient (e.g., specific to the patient's age, gender, weight and other factors), but this may not be possible or appropriate. Whenever more than one reference range is supplied, the differences between them SHOULD be provided in the reference range and/or age properties.",
"requirements": "Knowing what values are considered \"normal\" can help evaluate the significance of a particular result. Need to be able to provide multiple reference ranges for different contexts.",
"min": 0,
"max": "*",
"contentReference": "#Observation.referenceRange",
"mapping": [
{
"identity": "v2",
"map": "OBX.7"
},
{
"identity": "rim",
"map": "outboundRelationship[typeCode=REFV]/target[classCode=OBS, moodCode=EVN]"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Observation",
"path": "Observation",
"short": "Measurements and simple assertions",
"definition": "Measurements and simple assertions made about a patient, device or other subject.",
"comment": "Used for simple observations such as device measurements, laboratory atomic results, vital signs, height, weight, smoking status, comments, etc. Other resources are used to provide context for observations such as lab reports, etc.",
"alias": [
"Vital Signs",
"Measurement",
"Results",
"Tests"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "obs-7",
"severity": "error",
"human": "If code is the same as a component code then the value element associated with the code SHALL NOT be present",
"expression": "value.empty() or code!=component.code",
"xpath": "not(exists(f:*[starts-with(local-name(.), 'value')])) or not(count(for $coding in f:code/f:coding return parent::*/f:component/f:code/f:coding[f:code/@value=$coding/f:code/@value and f:system/@value=$coding/f:system/@value])=0)"
},
{
"key": "obs-6",
"severity": "error",
"human": "dataAbsentReason SHALL only be present if Observation.value[x] is not present",
"expression": "dataAbsentReason.empty() or value.empty()",
"xpath": "not(exists(f:dataAbsentReason)) or (not(exists(*[starts-with(local-name(.), 'value')])))"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "sct-concept",
"map": "< 363787002 |Observable entity|"
},
{
"identity": "v2",
"map": "OBX"
},
{
"identity": "rim",
"map": "Observation[classCode=OBS, moodCode=EVN]"
},
{
"identity": "w5",
"map": "clinical.diagnostics"
}
]
},
{
"id": "Observation.identifier",
"path": "Observation.identifier",
"short": "Business Identifier for observation",
"definition": "A unique identifier assigned to this observation.",
"requirements": "Allows observations to be distinguished and referenced.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "v2",
"map": "OBX.21 For OBX segments from systems without OBX-21 support a combination of ORC/OBR and OBX must be negotiated between trading partners to uniquely identify the OBX segment. Depending on how V2 has been implemented each of these may be an option: 1) OBR-3 + OBX-3 + OBX-4 or 2) OBR-3 + OBR-4 + OBX-3 + OBX-4 or 2) some other way to uniquely ID the OBR/ORC + OBX-3 + OBX-4."
},
{
"identity": "rim",
"map": "id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Observation.basedOn",
"path": "Observation.basedOn",
"short": "Fulfills plan, proposal or order",
"definition": "A plan, proposal or order that is fulfilled in whole or in part by this event.",
"requirements": "Allows tracing of authorization for the event and tracking whether proposals/recommendations were acted upon.",
"alias": [
"Fulfills"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DeviceRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ImmunizationRecommendation"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/NutritionOrder"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.basedOn"
},
{
"identity": "v2",
"map": "ORC"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target"
}
]
},
{
"id": "Observation.status",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-display-hint",
"valueString": "default: final"
}
],
"path": "Observation.status",
"short": "registered | preliminary | final | amended +",
"definition": "The status of the result value.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"requirements": "Need to track the status of individual results. Some results are finalized before the whole report is finalized.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationStatus"
}
],
"strength": "required",
"description": "Codes providing the status of an observation.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "sct-concept",
"map": "< 445584004 |Report by finality status|"
},
{
"identity": "v2",
"map": "OBX-11"
},
{
"identity": "rim",
"map": "status Amended & Final are differentiated by whether it is the subject of a ControlAct event with a type of \"revise\""
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Observation.category",
"path": "Observation.category",
"short": "Classification of type of observation",
"definition": "A code that classifies the general type of observation being made.",
"comment": "In addition to the required category valueset, this element allows various categorization schemes based on the owner’s definition of the category and effectively multiple categories can be used at once. The level of granularity is defined by the category concepts in the value set.",
"requirements": "Used for filtering what observations are retrieved and displayed.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationCategory"
}
],
"strength": "preferred",
"description": "Codes for high level observation categories.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"LIST\", moodCode=\"EVN\"].code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Observation.code",
"path": "Observation.code",
"short": "Type of observation (code / type)",
"definition": "Describes what was observed. Sometimes this is called the observation \"name\".",
"requirements": "Knowing what kind of observation is being made is essential to understanding the observation.",
"alias": [
"Name"
],
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationCode"
}
],
"strength": "example",
"description": "Codes identifying names of simple observations.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-codes"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.code"
},
{
"identity": "sct-concept",
"map": "< 363787002 |Observable entity| OR < 386053000 |Evaluation procedure|"
},
{
"identity": "v2",
"map": "OBX-3"
},
{
"identity": "rim",
"map": "code"
},
{
"identity": "sct-attr",
"map": "116680003 |Is a|"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Observation.subject",
"path": "Observation.subject",
"short": "Who and/or what this is about",
"definition": "The patient, or group of patients, location, or device whose characteristics (direct or indirect) are described by the observation and into whose record the observation is placed. Comments: Indirect characteristics may be those of a specimen, fetus, donor, other observer (for example a relative or EMT), or any observation made about the subject.",
"comment": "One would expect this element to be a cardinality of 1..1. The only circumstance in which the subject can be missing is when the observation is made by a device that does not know the patient. In this case, the observation SHALL be matched to a patient through some context/channel matching technique, and at this point, the observation should be updated.\r\rIf the target of the observation is different than the subject, the general extension [observation-focal-subject](extension-observation-focal-subject.html). may be used. However, the distinction between the patient's own value for an observation versus that of the fetus, or the donor or blood product unit, etc., are often specified in the observation code.",
"requirements": "Observations have no value if you don't know who or what they're about.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.subject"
},
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "rim",
"map": "participation[typeCode=SBJ]"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Observation.context",
"path": "Observation.context",
"short": "Healthcare event during which this observation is made",
"definition": "The healthcare event (e.g. a patient and healthcare provider interaction) during which this observation is made.",
"comment": "This will typically be the encounter the event occurred within, but some events may be initiated prior to or after the official completion of an encounter or episode but still be tied to the context of the encounter or episode (e.g. pre-admission lab tests).",
"requirements": "For some observations it may be important to know the link between an observation and a particular encounter.",
"alias": [
"Encounter"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.context"
},
{
"identity": "v2",
"map": "PV1"
},
{
"identity": "rim",
"map": "inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "Observation.effective[x]",
"path": "Observation.effective[x]",
"short": "Clinically relevant time/time-period for observation",
"definition": "The time or time-period the observed value is asserted as being true. For biological subjects - e.g. human patients - this is usually called the \"physiologically relevant time\". This is usually either the time of the procedure or of specimen collection, but very often the source of the date/time is not known, only the date/time itself.",
"comment": "At least a date should be present unless this observation is a historical report.",
"requirements": "Knowing when an observation was deemed true is important to its relevance as well as determining trends.",
"alias": [
"Occurrence"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence[x]"
},
{
"identity": "v2",
"map": "OBX-14, and/or OBX-19 after v2.4 (depends on who observation made)"
},
{
"identity": "rim",
"map": "effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Observation.issued",
"path": "Observation.issued",
"short": "Date/Time this was made available",
"definition": "The date and time this observation was made available to providers, typically after the results have been reviewed and verified.",
"comment": "Updated when the result is updated.",
"min": 0,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "OBR.22 (or MSH.7), or perhaps OBX-19 (depends on who observation made)"
},
{
"identity": "rim",
"map": "participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "Observation.performer",
"path": "Observation.performer",
"short": "Who is responsible for the observation",
"definition": "Who was responsible for asserting the observed value as \"true\".",
"requirements": "May give a degree of confidence in the observation and also indicates where follow-up questions should be directed.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.performer"
},
{
"identity": "v2",
"map": "OBX.15 / (Practitioner) OBX-16, PRT-5:PRT-4='RO' / (Device) OBX-18 , PRT-10:PRT-4='EQUIP' / (Organization) OBX-23, PRT-8:PRT-4='PO'"
},
{
"identity": "rim",
"map": "participation[typeCode=PRF]"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Observation.value[x]",
"path": "Observation.value[x]",
"short": "Actual result",
"definition": "The information determined as a result of making the observation, if the information has a simple value.",
"comment": "Normally, an observation will have either a single value or a set of related observations. A few observations (e.g. Apgar score) may have both a value and related observations (for an Apgar score, the observations from which the measure is derived). If a value is present, the datatype for this element should be determined by Observation.code. This element has a variable name depending on the type as follows: valueQuantity, valueCodeableConcept, valueString, valueBoolean, valueRange, valueRatio, valueSampledData, valueAttachment, valueTime, valueDateTime, or valuePeriod. (The name format is \"'value' + the type name\" with a capital on the first letter of the type).\r\r\rIf the data element is usually coded or if the type associated with the Observation.value defines a coded value, use CodeableConcept instead of string datatype even if the value is uncoded text. A value set is bound to the ValueCodeableConcept element. For further discussion and examples see the [notes section](observation.html#notes) below.",
"requirements": "An observation exists to have a value, though it may not if it is in error, or if it represents a group of observations.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity"
},
{
"code": "CodeableConcept"
},
{
"code": "string"
},
{
"code": "boolean"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "SampledData"
},
{
"code": "Attachment"
},
{
"code": "time"
},
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"condition": [
"obs-7"
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.notDone, Event.notDoneReason (maps to valeu[x] or dataAbsentReason)"
},
{
"identity": "sct-concept",
"map": "< 441742003 |Evaluation finding|"
},
{
"identity": "v2",
"map": "OBX.2, OBX.5, OBX.6"
},
{
"identity": "rim",
"map": "value"
},
{
"identity": "sct-attr",
"map": "363714003 |Interprets|"
}
]
},
{
"id": "Observation.dataAbsentReason",
"path": "Observation.dataAbsentReason",
"short": "Why the result is missing",
"definition": "Provides a reason why the expected value in the element Observation.value[x] is missing.",
"comment": "Null or exceptional values can be represented two ways in FHIR Observations. One way is to simply include them in the value set and represent the exceptions in the value. For example, measurement values for a serology test could be \"detected\", \"not detected\", \"inconclusive\", or \"specimen unsatisfactory\". The alternate way is to use the value element for actual observations and use the explicit dataAbsentReason element to record exceptional values. For example, the dataAbsentReason code \"error\" could be used when the measurement was not completed. Note that an observation may only be reported if there are values to report. For example differential cell counts values may be reported only when > 0. Because of these options, use-case agreements are required to interpret general observations for null or exceptional values.",
"requirements": "For many results it is necessary to handle exceptional values in measurements.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"obs-6"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationValueAbsentReason"
}
],
"strength": "extensible",
"description": "Codes specifying why the result (Observation.value[x]) is missing.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-valueabsentreason"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.notDone, Event.notDoneReason (maps to valeu[x] or dataAbsentReason)"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "value.nullFlavor"
}
]
},
{
"id": "Observation.interpretation",
"path": "Observation.interpretation",
"short": "High, low, normal, etc.",
"definition": "The assessment made based on the result of the observation. Intended as a simple compact code often placed adjacent to the result value in reports and flow sheets to signal the meaning/normalcy status of the result. Otherwise known as abnormal flag.",
"requirements": "For some results, particularly numeric results, an interpretation is necessary to fully understand the significance of a result.",
"alias": [
"Abnormal Flag"
],
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationInterpretation"
}
],
"strength": "extensible",
"description": "Codes identifying interpretations of observations.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-interpretation"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 260245000 |Findings values|"
},
{
"identity": "v2",
"map": "OBX-8"
},
{
"identity": "rim",
"map": "interpretationCode"
},
{
"identity": "sct-attr",
"map": "363713009 |Has interpretation|"
}
]
},
{
"id": "Observation.comment",
"path": "Observation.comment",
"short": "Comments about result",
"definition": "May include statements about significant, unexpected or unreliable values, or information about the source of the value where this may be relevant to the interpretation of the result.",
"requirements": "Need to be able to provide free text additional information.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.note"
},
{
"identity": "v2",
"map": "NTE.3 (partner NTE to OBX, or sometimes another (child?) OBX)"
},
{
"identity": "rim",
"map": "subjectOf.observationEvent[code=\"annotation\"].value"
}
]
},
{
"id": "Observation.bodySite",
"path": "Observation.bodySite",
"short": "Observed body part",
"definition": "Indicates the site on the subject's body where the observation was made (i.e. the target site).",
"comment": "Only used if not implicit in code found in Observation.code. In many systems, this may be represented as a related observation instead of an inline component. If the use case requires BodySite to be handled as a separate resource (e.g. to identify and track separately) then use the standard extension[ body-site-instance](extension-body-site-instance.html).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "BodySite"
}
],
"strength": "example",
"description": "Codes describing anatomical locations. May include laterality.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/body-site"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 123037004 |Body structure|"
},
{
"identity": "v2",
"map": "OBX-20"
},
{
"identity": "rim",
"map": "targetSiteCode"
},
{
"identity": "sct-attr",
"map": "718497002 |Inherent location|"
}
]
},
{
"id": "Observation.method",
"path": "Observation.method",
"short": "How it was done",
"definition": "Indicates the mechanism used to perform the observation.",
"comment": "Only used if not implicit in code for Observation.code.",
"requirements": "In some cases, method can impact results and is thus used for determining whether results can be compared or determining significance of results.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationMethod"
}
],
"strength": "example",
"description": "Methods for simple observations.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-methods"
}
},
"mapping": [
{
"identity": "v2",
"map": "OBX-17"
},
{
"identity": "rim",
"map": "methodCode"
}
]
},
{
"id": "Observation.specimen",
"path": "Observation.specimen",
"short": "Specimen used for this observation",
"definition": "The specimen that was used when this observation was made.",
"comment": "Should only be used if not implicit in code found in `Observation.code`. Observations are not made on specimens themselves; they are made on a subject, but in many cases by the means of a specimen. Note that although specimens are often involved, they are not always tracked and reported explicitly. Also note that observation resources may be used in contexts that track the specimen explicitly (e.g. Diagnostic Report).",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Specimen"
}
],
"mapping": [
{
"identity": "sct-concept",
"map": "< 123038009 |Specimen|"
},
{
"identity": "v2",
"map": "SPM segment"
},
{
"identity": "rim",
"map": "participation[typeCode=SPC].specimen"
},
{
"identity": "sct-attr",
"map": "704319004 |Inherent in|"
}
]
},
{
"id": "Observation.device",
"path": "Observation.device",
"short": "(Measurement) Device",
"definition": "The device used to generate the observation data.",
"comment": "An extension should be used if further typing of the device is needed. Devices used to support obtaining an observation can be represented using either an extension or through the Observation.related element.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DeviceMetric"
}
],
"mapping": [
{
"identity": "sct-concept",
"map": "< 49062001 |Device|"
},
{
"identity": "v2",
"map": "OBX-17 / PRT -10"
},
{
"identity": "rim",
"map": "participation[typeCode=DEV]"
},
{
"identity": "sct-attr",
"map": "424226004 |Using device|"
}
]
},
{
"id": "Observation.referenceRange",
"path": "Observation.referenceRange",
"short": "Provides guide for interpretation",
"definition": "Guidance on how to interpret the value by comparison to a normal or recommended range.",
"comment": "Most observations only have one generic reference range. Systems MAY choose to restrict to only supplying the relevant reference range based on knowledge about the patient (e.g., specific to the patient's age, gender, weight and other factors), but this may not be possible or appropriate. Whenever more than one reference range is supplied, the differences between them SHOULD be provided in the reference range and/or age properties.",
"requirements": "Knowing what values are considered \"normal\" can help evaluate the significance of a particular result. Need to be able to provide multiple reference ranges for different contexts.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "obs-3",
"severity": "error",
"human": "Must have at least a low or a high or text",
"expression": "low.exists() or high.exists() or text.exists()",
"xpath": "(exists(f:low) or exists(f:high)or exists(f:text))"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX.7"
},
{
"identity": "rim",
"map": "outboundRelationship[typeCode=REFV]/target[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "Observation.referenceRange.low",
"path": "Observation.referenceRange.low",
"short": "Low Range, if relevant",
"definition": "The value of the low bound of the reference range. The low bound of the reference range endpoint is inclusive of the value (e.g. reference range is >=5 - <=9). If the low bound is omitted, it is assumed to be meaningless (e.g. reference range is <=2.3).",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"condition": [
"obs-3"
],
"mapping": [
{
"identity": "v2",
"map": "OBX-7"
},
{
"identity": "rim",
"map": "value:IVL_PQ.low"
}
]
},
{
"id": "Observation.referenceRange.high",
"path": "Observation.referenceRange.high",
"short": "High Range, if relevant",
"definition": "The value of the high bound of the reference range. The high bound of the reference range endpoint is inclusive of the value (e.g. reference range is >=5 - <=9). If the high bound is omitted, it is assumed to be meaningless (e.g. reference range is >= 2.3).",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"condition": [
"obs-3"
],
"mapping": [
{
"identity": "v2",
"map": "OBX-7"
},
{
"identity": "rim",
"map": "value:IVL_PQ.high"
}
]
},
{
"id": "Observation.referenceRange.type",
"path": "Observation.referenceRange.type",
"short": "Reference range qualifier",
"definition": "Codes to indicate the what part of the targeted reference population it applies to. For example, the normal or therapeutic range.",
"comment": "This SHOULD be populated if there is more than one range. If this element is not present then the normal range is assumed.",
"requirements": "Need to be able to say what kind of reference range this is - normal, recommended, therapeutic, etc, - for proper interpretation.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationRangeMeaning"
}
],
"strength": "extensible",
"description": "Code for the meaning of a reference range.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/referencerange-meaning"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 260245000 |Findings values| OR \r< 365860008 |General clinical state finding| \rOR \r< 250171008 |Clinical history or observation findings| OR \r< 415229000 |Racial group| OR \r< 365400002 |Finding of puberty stage| OR\r< 443938003 |Procedure carried out on subject|"
},
{
"identity": "v2",
"map": "OBX-10"
},
{
"identity": "rim",
"map": "interpretationCode"
}
]
},
{
"id": "Observation.referenceRange.appliesTo",
"path": "Observation.referenceRange.appliesTo",
"short": "Reference range population",
"definition": "Codes to indicate the target population this reference range applies to. For example, a reference range may be based on the normal population or a particular sex or race.",
"comment": "This SHOULD be populated if there is more than one range. If this element is not present then the normal population is assumed.",
"requirements": "Need to be able to identify the target population for proper interpretation.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationRangeType"
}
],
"strength": "example",
"description": "Codes identifying the population the reference range applies to.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/referencerange-appliesto"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 260245000 |Findings values| OR \r< 365860008 |General clinical state finding| \rOR \r< 250171008 |Clinical history or observation findings| OR \r< 415229000 |Racial group| OR \r< 365400002 |Finding of puberty stage| OR\r< 443938003 |Procedure carried out on subject|"
},
{
"identity": "v2",
"map": "OBX-10"
},
{
"identity": "rim",
"map": "interpretationCode"
}
]
},
{
"id": "Observation.referenceRange.age",
"path": "Observation.referenceRange.age",
"short": "Applicable age range, if relevant",
"definition": "The age at which this reference range is applicable. This is a neonatal age (e.g. number of weeks at term) if the meaning says so.",
"requirements": "Some analytes vary greatly over age.",
"min": 0,
"max": "1",
"type": [
{
"code": "Range"
}
],
"mapping": [
{
"identity": "rim",
"map": "outboundRelationship[typeCode=PRCN].targetObservationCriterion[code=\"age\"].value"
}
]
},
{
"id": "Observation.referenceRange.text",
"path": "Observation.referenceRange.text",
"short": "Text based reference range in an observation",
"definition": "Text based reference range in an observation which may be used when a quantitative range is not appropriate for an observation. An example would be a reference value of \"Negative\" or a list or table of 'normals'.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX-7"
},
{
"identity": "rim",
"map": "value:ST"
}
]
},
{
"id": "Observation.related",
"path": "Observation.related",
"short": "Resource related to this observation",
"definition": "A reference to another resource (usually another Observation) whose relationship is defined by the relationship type code.",
"comment": "For a discussion on the ways Observations can assembled in groups together see [Notes below](observation.html#4.20.4).",
"requirements": "Normally, an observation will have either a value or a set of related observations. A few observations (e.g. Apgar score) may have both a value and a set of related observations or sometimes a QuestionnaireResponse from which the measure is derived.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "Relationships established by OBX-4 usage"
},
{
"identity": "rim",
"map": "outBoundRelationship"
}
]
},
{
"id": "Observation.related.type",
"path": "Observation.related.type",
"short": "has-member | derived-from | sequel-to | replaces | qualified-by | interfered-by",
"definition": "A code specifying the kind of relationship that exists with the target resource.",
"comment": "The \"derived-from\" type is the only logical choice when referencing the QuestionnaireAnswer resource.",
"requirements": "A relationship type SHOULD be provided.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationRelationshipType"
}
],
"strength": "required",
"description": "Codes specifying how two observations are related.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-relationshiptypes"
}
},
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".typeCode"
}
]
},
{
"id": "Observation.related.target",
"path": "Observation.related.target",
"short": "Resource that is related to this one",
"definition": "A reference to the observation or [QuestionnaireResponse](questionnaireresponse.html#) resource that is related to this observation.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/QuestionnaireResponse"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Sequence"
}
],
"mapping": [
{
"identity": "rim",
"map": ".targetObservation"
}
]
},
{
"id": "Observation.component",
"path": "Observation.component",
"short": "Component results",
"definition": "Some observations have multiple component observations. These component observations are expressed as separate code value pairs that share the same attributes. Examples include systolic and diastolic component observations for blood pressure measurement and multiple component observations for genetics observations.",
"comment": "For a discussion on the ways Observations can be assembled in groups together see [Notes](observation.html#notes) below.",
"requirements": "Component observations share the same attributes in the Observation resource as the primary observation and are always treated a part of a single observation (they are not separable). However, the reference range for the primary observation value is not inherited by the component values and is required when appropriate for each component observation.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "containment by OBX-4?"
},
{
"identity": "rim",
"map": "outBoundRelationship[typeCode=COMP]"
}
]
},
{
"id": "Observation.component.code",
"path": "Observation.component.code",
"short": "Type of component observation (code / type)",
"definition": "Describes what was observed. Sometimes this is called the observation \"code\".",
"requirements": "Knowing what kind of observation is being made is essential to understanding the observation.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationCode"
}
],
"strength": "example",
"description": "Codes identifying names of simple observations.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-codes"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 363787002 |Observable entity| OR \r< 386053000 |Evaluation procedure|"
},
{
"identity": "v2",
"map": "OBX-3"
},
{
"identity": "rim",
"map": "code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Observation.component.value[x]",
"path": "Observation.component.value[x]",
"short": "Actual component result",
"definition": "The information determined as a result of making the observation, if the information has a simple value.",
"comment": "Normally, an observation will have either a single value or a set of related observations. A few observations (e.g. Apgar score) may have both a value and related observations (for an Apgar score, the observations from which the measure is derived). If a value is present, the datatype for this element should be determined by Observation.code. A CodeableConcept with just a text would be used instead of a string if the field was usually coded, or if the type associated with the Observation.code defines a coded value. For boolean values use valueCodeableConcept and select codes from (these \"yes/no\" concepts can be mapped to the display name \"true/false\" or other mutually exclusive terms that may be needed\"). The element, Observation.value[x], has a variable name depending on the type as follows: valueQuantity, valueCodeableConcept, valueRatio, valueChoice, valuePeriod, valueSampleData, or valueString (the name format is \"'value' + the type name\" with a capital on the first letter of the type).",
"requirements": "An observation exists to have a value, though it may not if it is in error, or if it represents a group of observations.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity"
},
{
"code": "CodeableConcept"
},
{
"code": "string"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "SampledData"
},
{
"code": "Attachment"
},
{
"code": "time"
},
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "sct-concept",
"map": "363714003 |Interprets| < 441742003 |Evaluation finding|"
},
{
"identity": "v2",
"map": "OBX.2, OBX.5, OBX.6"
},
{
"identity": "rim",
"map": "value"
},
{
"identity": "sct-attr",
"map": "363714003 |Interprets|"
}
]
},
{
"id": "Observation.component.dataAbsentReason",
"path": "Observation.component.dataAbsentReason",
"short": "Why the component result is missing",
"definition": "Provides a reason why the expected value in the element Observation.value[x] is missing.",
"comment": "\"Null\" or exceptional values can be represented two ways in FHIR Observations. One way is to simply include them in the value set and represent the exceptions in the value. For example, measurement values for a serology test could be \"detected\", \"not detected\", \"inconclusive\", or \"test not done\". The alternate way is to use the value element for actual observations and use the explicit dataAbsentReason element to record exceptional values. For example, the dataAbsentReason code \"error\" could be used when the measurement was not completed. Because of these options, use-case agreements are required to interpret general observations for exceptional values.",
"requirements": "For many results it is necessary to handle exceptional values in measurements.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"obs-6"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationValueAbsentReason"
}
],
"strength": "extensible",
"description": "Codes specifying why the result (Observation.value[x]) is missing.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-valueabsentreason"
}
},
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "value.nullFlavor"
}
]
},
{
"id": "Observation.component.interpretation",
"path": "Observation.component.interpretation",
"short": "High, low, normal, etc.",
"definition": "The assessment made based on the result of the observation. Intended as a simple compact code often placed adjacent to the result value in reports and flow sheets to signal the meaning/normalcy status of the result. Otherwise known as abnormal flag.",
"comment": "The component interpretation applies only to the individual component value. For an overall interpretation all components together use thes Observation.interpretation element.",
"requirements": "For some results, particularly numeric results, an interpretation is necessary to fully understand the significance of a result.",
"alias": [
"Abnormal Flag"
],
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ObservationInterpretation"
}
],
"strength": "extensible",
"description": "Codes identifying interpretations of observations.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-interpretation"
}
},
"mapping": [
{
"identity": "sct-concept",
"map": "< 260245000 |Findings values|"
},
{
"identity": "v2",
"map": "OBX-8"
},
{
"identity": "rim",
"map": "interpretationCode"
},
{
"identity": "sct-attr",
"map": "363713009 |Has interpretation|"
}
]
},
{
"id": "Observation.component.referenceRange",
"path": "Observation.component.referenceRange",
"short": "Provides guide for interpretation of component result",
"definition": "Guidance on how to interpret the value by comparison to a normal or recommended range.",
"comment": "Most observations only have one generic reference range. Systems MAY choose to restrict to only supplying the relevant reference range based on knowledge about the patient (e.g., specific to the patient's age, gender, weight and other factors), but this may not be possible or appropriate. Whenever more than one reference range is supplied, the differences between them SHOULD be provided in the reference range and/or age properties.",
"requirements": "Knowing what values are considered \"normal\" can help evaluate the significance of a particular result. Need to be able to provide multiple reference ranges for different contexts.",
"min": 0,
"max": "*",
"contentReference": "#Observation.referenceRange",
"mapping": [
{
"identity": "v2",
"map": "OBX.7"
},
{
"identity": "rim",
"map": "outboundRelationship[typeCode=REFV]/target[classCode=OBS, moodCode=EVN]"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/OperationDefinition",
"resource": {
"resourceType": "StructureDefinition",
"id": "OperationDefinition",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints OperationDefinition DomainResource Definition of an operation or a named query
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension url Σ 0..1 uri Logical URI to reference this operation definition (globally unique) version Σ 0..1 string Business version of the operation definition name Σ 1..1 string Name for this operation definition (computer friendly) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) kind 1..1 code operation | query
OperationKind (Required) experimental ?!Σ 0..1 boolean For testing purposes, not real usage date Σ 0..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) contact Σ 0..* ContactDetail Contact details for the publisher
description 0..1 markdown Natural language description of the operation definition useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for operation definition (if applicable)
Jurisdiction ValueSet (Extensible)
purpose 0..1 markdown Why this operation definition is defined idempotent Σ 0..1 boolean Whether content is unchanged by the operation code Σ 1..1 code Name used to invoke the operation comment 0..1 string Additional information about use base Σ 0..1 Reference(OperationDefinition) Marks this as a profile of the base resource Σ 0..* code Types this operation applies to
ResourceType (Required)
system Σ 1..1 boolean Invoke at the system level? type Σ 1..1 boolean Invole at the type level? instance Σ 1..1 boolean Invoke on an instance? parameter I 0..* BackboneElement Parameters for the operation/query
+ Either a type must be provided, or parts
+ A search type can only be specified for parameters of type string
name 1..1 code Name in Parameters.parameter.name or in URL use 1..1 code in | out
OperationParameterUse (Required) min 1..1 integer Minimum Cardinality max 1..1 string Maximum Cardinality (a number or *) documentation 0..1 string Description of meaning/use type I 0..1 code What type this parameter has
FHIRAllTypes (Required) searchType I 0..1 code number | date | string | token | reference | composite | quantity | uri
SearchParamType (Required) profile 0..1 Reference(StructureDefinition) Profile on the type binding 0..1 BackboneElement ValueSet details if this is coded strength 1..1 code required | extensible | preferred | example
BindingStrength (Required) valueSet[x] 1..1 Source of value set valueSetUri uri valueSetReference Reference(ValueSet) part I 0..* see parameter Parts of a nested Parameter
overload 0..* BackboneElement Define overloaded variants for when generating code
parameterName 0..* string Name of parameter to include in overload
comment 0..1 string Comments to go on overload
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 4
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/OperationDefinition",
"name": "OperationDefinition",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for OperationDefinition Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "objimpl",
"uri": "http://hl7.org/fhir/object-implementation",
"name": "Object Implementation Information"
}
],
"kind": "resource",
"abstract": false,
"type": "OperationDefinition",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"_baseDefinition": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-codegen-super",
"valueString": "MetadataResource"
}
]
},
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "OperationDefinition",
"path": "OperationDefinition",
"short": "Definition of an operation or a named query",
"definition": "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Definition"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "conformance.behavior"
}
]
},
{
"id": "OperationDefinition.id",
"path": "OperationDefinition.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.meta",
"path": "OperationDefinition.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.implicitRules",
"path": "OperationDefinition.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "OperationDefinition.language",
"path": "OperationDefinition.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "OperationDefinition.text",
"path": "OperationDefinition.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "OperationDefinition.contained",
"path": "OperationDefinition.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "OperationDefinition.extension",
"path": "OperationDefinition.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "OperationDefinition.modifierExtension",
"path": "OperationDefinition.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "OperationDefinition.url",
"path": "OperationDefinition.url",
"short": "Logical URI to reference this operation definition (globally unique)",
"definition": "An absolute URI that is used to identify this operation definition when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this operation definition is (or will be) published. The URL SHOULD include the major version of the operation definition. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the operation definition to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.url"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "OperationDefinition.version",
"path": "OperationDefinition.version",
"short": "Business version of the operation definition",
"definition": "The identifier that is used to identify this version of the operation definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the operation definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different operation definition instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the operation definition with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.version"
},
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "OperationDefinition.name",
"path": "OperationDefinition.name",
"short": "Name for this operation definition (computer friendly)",
"definition": "A natural language name identifying the operation definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.title"
}
]
},
{
"id": "OperationDefinition.status",
"path": "OperationDefinition.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this operation definition. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of operation definitions that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired operation definition without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.status (different ValueSet)"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "OperationDefinition.kind",
"path": "OperationDefinition.kind",
"short": "operation | query",
"definition": "Whether this is an operation or a named query.",
"comment": "Named queries are invoked differently, and have different capabilities.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "OperationKind"
}
],
"strength": "required",
"description": "Whether an operation is a normal operation or a query.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/operation-kind"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "OperationDefinition.experimental",
"path": "OperationDefinition.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this operation definition is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of operation definition that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental operation definition in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level operation definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.experimental"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "OperationDefinition.date",
"path": "OperationDefinition.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the operation definition was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the operation definition changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the operation definition. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.date"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "OperationDefinition.publisher",
"path": "OperationDefinition.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the operation definition.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the operation definition is the organization or individual primarily responsible for the maintenance and upkeep of the operation definition. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the operation definition. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the operation definition. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.publisher"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "OperationDefinition.contact",
"path": "OperationDefinition.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.contact"
}
]
},
{
"id": "OperationDefinition.description",
"path": "OperationDefinition.description",
"short": "Natural language description of the operation definition",
"definition": "A free text natural language description of the operation definition from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the operation definition was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the operation definition as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.description"
}
]
},
{
"id": "OperationDefinition.useContext",
"path": "OperationDefinition.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate operation definition instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.useContext"
}
]
},
{
"id": "OperationDefinition.jurisdiction",
"path": "OperationDefinition.jurisdiction",
"short": "Intended jurisdiction for operation definition (if applicable)",
"definition": "A legal or geographic region in which the operation definition is intended to be used.",
"comment": "It may be possible for the operation definition to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.jurisdiction"
}
]
},
{
"id": "OperationDefinition.purpose",
"path": "OperationDefinition.purpose",
"short": "Why this operation definition is defined",
"definition": "Explaination of why this operation definition is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the operation definition Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this operation definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.purpose"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "OperationDefinition.idempotent",
"path": "OperationDefinition.idempotent",
"short": "Whether content is unchanged by the operation",
"definition": "Operations that are idempotent (see [HTTP specification definition of idempotent](http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html)) may be invoked by performing an HTTP GET operation instead of a POST.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.code",
"path": "OperationDefinition.code",
"short": "Name used to invoke the operation",
"definition": "The name used to invoke the operation.",
"comment": "The code does not include the '$' prefix that is always included in the URL when the operation is invoked.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.comment",
"path": "OperationDefinition.comment",
"short": "Additional information about use",
"definition": "Additional information about how to use this operation or named query.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "OperationDefinition.base",
"path": "OperationDefinition.base",
"short": "Marks this as a profile of the base",
"definition": "Indicates that this operation definition is a constraining profile on the base.",
"comment": "A constrained profile can make optional parameters required or not used and clarify documentation.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/OperationDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.definition"
}
]
},
{
"id": "OperationDefinition.resource",
"path": "OperationDefinition.resource",
"short": "Types this operation applies to",
"definition": "The types on which this operation can be executed.",
"comment": "If the type is an abstract resource (\"Resource\" or \"DomainResource\") then the operation can be invoked on any concrete specialization.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResourceType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "One of the resource types defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/resource-types"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.subjectCodableConcept"
}
]
},
{
"id": "OperationDefinition.system",
"path": "OperationDefinition.system",
"short": "Invoke at the system level?",
"definition": "Indicates whether this operation or named query can be invoked at the system level (e.g. without needing to choose a resource type for the context).",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.type",
"path": "OperationDefinition.type",
"short": "Invole at the type level?",
"definition": "Indicates whether this operation or named query can be invoked at the resource type level for any given resource type level (e.g. without needing to choose a specific resource id for the context).",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.instance",
"path": "OperationDefinition.instance",
"short": "Invoke on an instance?",
"definition": "Indicates whether this operation can be invoked on a particular instance of one of the given types.",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.parameter",
"path": "OperationDefinition.parameter",
"short": "Parameters for the operation/query",
"definition": "The parameters for the operation/query.",
"comment": "Query Definitions only have one output parameter, named \"result\". This may not be described, but can be to allow a profile to be defined.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "opd-1",
"severity": "error",
"human": "Either a type must be provided, or parts",
"expression": "type.exists() or part.exists()",
"xpath": "exists(f:type) or exists(f:part)"
},
{
"key": "opd-2",
"severity": "error",
"human": "A search type can only be specified for parameters of type string",
"expression": "searchType implies type = 'string'",
"xpath": "not(exists(f:searchType)) or (f:type/@value = 'string')"
}
]
},
{
"id": "OperationDefinition.parameter.id",
"path": "OperationDefinition.parameter.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "OperationDefinition.parameter.extension",
"path": "OperationDefinition.parameter.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "OperationDefinition.parameter.modifierExtension",
"path": "OperationDefinition.parameter.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "OperationDefinition.parameter.name",
"path": "OperationDefinition.parameter.name",
"short": "Name in Parameters.parameter.name or in URL",
"definition": "The name of used to identify the parameter.",
"comment": "This name must be a token (start with a letter in a..z, and only contain letters, numerals, and underscore. Note that for search parameters (type = string, with a search type), the name may be altered by the search modifiers.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
]
},
{
"id": "OperationDefinition.parameter.use",
"path": "OperationDefinition.parameter.use",
"short": "in | out",
"definition": "Whether this is an input or an output parameter.",
"comment": "If a parameter name is used for both an input and an output parameter, the parameter should be defined twice.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "OperationParameterUse"
}
],
"strength": "required",
"description": "Whether an operation parameter is an input or an output parameter.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/operation-parameter-use"
}
}
},
{
"id": "OperationDefinition.parameter.min",
"path": "OperationDefinition.parameter.min",
"short": "Minimum Cardinality",
"definition": "The minimum number of times this parameter SHALL appear in the request or response.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "OperationDefinition.parameter.max",
"path": "OperationDefinition.parameter.max",
"short": "Maximum Cardinality (a number or *)",
"definition": "The maximum number of times this element is permitted to appear in the request or response.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "OperationDefinition.parameter.documentation",
"path": "OperationDefinition.parameter.documentation",
"short": "Description of meaning/use",
"definition": "Describes the meaning or use of this parameter.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "OperationDefinition.parameter.type",
"path": "OperationDefinition.parameter.type",
"short": "What type this parameter has",
"definition": "The type for this parameter.",
"comment": "if there is no stated parameter, then the parameter is a multi-part parameter; type and must have at least one part defined.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"opd-1"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FHIRAllTypes"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Either an abstract type, a resource or a data type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-types"
}
}
},
{
"id": "OperationDefinition.parameter.searchType",
"path": "OperationDefinition.parameter.searchType",
"short": "number | date | string | token | reference | composite | quantity | uri",
"definition": "How the parameter is understood as a search parameter. This is only used if the parameter type is 'string'.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"opd-2"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SearchParamType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Data types allowed to be used for search parameters.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/search-param-type"
}
}
},
{
"id": "OperationDefinition.parameter.profile",
"path": "OperationDefinition.parameter.profile",
"short": "Profile on the type",
"definition": "A profile the specifies the rules that this parameter must conform to.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/StructureDefinition"
}
]
},
{
"id": "OperationDefinition.parameter.binding",
"path": "OperationDefinition.parameter.binding",
"short": "ValueSet details if this is coded",
"definition": "Binds to a value set if this parameter is coded (code, Coding, CodeableConcept).",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "OperationDefinition.parameter.binding.id",
"path": "OperationDefinition.parameter.binding.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "OperationDefinition.parameter.binding.extension",
"path": "OperationDefinition.parameter.binding.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "OperationDefinition.parameter.binding.modifierExtension",
"path": "OperationDefinition.parameter.binding.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "OperationDefinition.parameter.binding.strength",
"path": "OperationDefinition.parameter.binding.strength",
"short": "required | extensible | preferred | example",
"definition": "Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.",
"comment": "For further discussion, see [Using Terminologies](terminologies.html).",
"alias": [
"conformance",
"extensibility"
],
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "BindingStrength"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Indication of the degree of conformance expectations associated with a binding.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/binding-strength"
}
}
},
{
"id": "OperationDefinition.parameter.binding.valueSet[x]",
"path": "OperationDefinition.parameter.binding.valueSet[x]",
"short": "Source of value set",
"definition": "Points to the value set or external definition (e.g. implicit value set) that identifies the set of codes to be used.",
"comment": "For value sets with a referenceResource, the display can contain the value set description. The reference may be version-specific or not.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ValueSet"
}
]
},
{
"id": "OperationDefinition.parameter.part",
"path": "OperationDefinition.parameter.part",
"short": "Parts of a nested Parameter",
"definition": "The parts of a nested Parameter.",
"comment": "Query Definitions only have one output parameter, named \"result\". This may not be described, but can be to allow a profile to be defined.",
"min": 0,
"max": "*",
"contentReference": "#OperationDefinition.parameter",
"condition": [
"opd-1"
]
},
{
"id": "OperationDefinition.overload",
"path": "OperationDefinition.overload",
"short": "Define overloaded variants for when generating code",
"definition": "Defines an appropriate combination of parameters to use when invoking this operation, to help code generators when generating overloaded parameter sets for this operation.",
"comment": "The combinations are suggestions as to which sets of parameters to use together, but the combinations are not intended to be authoritative.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "OperationDefinition.overload.id",
"path": "OperationDefinition.overload.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "OperationDefinition.overload.extension",
"path": "OperationDefinition.overload.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "OperationDefinition.overload.modifierExtension",
"path": "OperationDefinition.overload.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "OperationDefinition.overload.parameterName",
"path": "OperationDefinition.overload.parameterName",
"short": "Name of parameter to include in overload",
"definition": "Name of parameter to include in overload.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
]
},
{
"id": "OperationDefinition.overload.comment",
"path": "OperationDefinition.overload.comment",
"short": "Comments to go on overload",
"definition": "Comments to go on overload.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
}
]
},
"differential": {
"element": [
{
"id": "OperationDefinition",
"path": "OperationDefinition",
"short": "Definition of an operation or a named query",
"definition": "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Definition"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "conformance.behavior"
}
]
},
{
"id": "OperationDefinition.url",
"path": "OperationDefinition.url",
"short": "Logical URI to reference this operation definition (globally unique)",
"definition": "An absolute URI that is used to identify this operation definition when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this operation definition is (or will be) published. The URL SHOULD include the major version of the operation definition. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the operation definition to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.url"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "OperationDefinition.version",
"path": "OperationDefinition.version",
"short": "Business version of the operation definition",
"definition": "The identifier that is used to identify this version of the operation definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the operation definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different operation definition instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the operation definition with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.version"
},
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "OperationDefinition.name",
"path": "OperationDefinition.name",
"short": "Name for this operation definition (computer friendly)",
"definition": "A natural language name identifying the operation definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.title"
}
]
},
{
"id": "OperationDefinition.status",
"path": "OperationDefinition.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this operation definition. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of operation definitions that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired operation definition without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.status (different ValueSet)"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "OperationDefinition.kind",
"path": "OperationDefinition.kind",
"short": "operation | query",
"definition": "Whether this is an operation or a named query.",
"comment": "Named queries are invoked differently, and have different capabilities.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "OperationKind"
}
],
"strength": "required",
"description": "Whether an operation is a normal operation or a query.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/operation-kind"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "OperationDefinition.experimental",
"path": "OperationDefinition.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this operation definition is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of operation definition that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental operation definition in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level operation definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.experimental"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "OperationDefinition.date",
"path": "OperationDefinition.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the operation definition was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the operation definition changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the operation definition. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.date"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "OperationDefinition.publisher",
"path": "OperationDefinition.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the operation definition.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the operation definition is the organization or individual primarily responsible for the maintenance and upkeep of the operation definition. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the operation definition. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the operation definition. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.publisher"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "OperationDefinition.contact",
"path": "OperationDefinition.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.contact"
}
]
},
{
"id": "OperationDefinition.description",
"path": "OperationDefinition.description",
"short": "Natural language description of the operation definition",
"definition": "A free text natural language description of the operation definition from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the operation definition was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the operation definition as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.description"
}
]
},
{
"id": "OperationDefinition.useContext",
"path": "OperationDefinition.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate operation definition instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.useContext"
}
]
},
{
"id": "OperationDefinition.jurisdiction",
"path": "OperationDefinition.jurisdiction",
"short": "Intended jurisdiction for operation definition (if applicable)",
"definition": "A legal or geographic region in which the operation definition is intended to be used.",
"comment": "It may be possible for the operation definition to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.jurisdiction"
}
]
},
{
"id": "OperationDefinition.purpose",
"path": "OperationDefinition.purpose",
"short": "Why this operation definition is defined",
"definition": "Explaination of why this operation definition is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the operation definition Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this operation definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.purpose"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "OperationDefinition.idempotent",
"path": "OperationDefinition.idempotent",
"short": "Whether content is unchanged by the operation",
"definition": "Operations that are idempotent (see [HTTP specification definition of idempotent](http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html)) may be invoked by performing an HTTP GET operation instead of a POST.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.code",
"path": "OperationDefinition.code",
"short": "Name used to invoke the operation",
"definition": "The name used to invoke the operation.",
"comment": "The code does not include the '$' prefix that is always included in the URL when the operation is invoked.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.comment",
"path": "OperationDefinition.comment",
"short": "Additional information about use",
"definition": "Additional information about how to use this operation or named query.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "OperationDefinition.base",
"path": "OperationDefinition.base",
"short": "Marks this as a profile of the base",
"definition": "Indicates that this operation definition is a constraining profile on the base.",
"comment": "A constrained profile can make optional parameters required or not used and clarify documentation.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/OperationDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.definition"
}
]
},
{
"id": "OperationDefinition.resource",
"path": "OperationDefinition.resource",
"short": "Types this operation applies to",
"definition": "The types on which this operation can be executed.",
"comment": "If the type is an abstract resource (\"Resource\" or \"DomainResource\") then the operation can be invoked on any concrete specialization.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResourceType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "One of the resource types defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/resource-types"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.subjectCodableConcept"
}
]
},
{
"id": "OperationDefinition.system",
"path": "OperationDefinition.system",
"short": "Invoke at the system level?",
"definition": "Indicates whether this operation or named query can be invoked at the system level (e.g. without needing to choose a resource type for the context).",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.type",
"path": "OperationDefinition.type",
"short": "Invole at the type level?",
"definition": "Indicates whether this operation or named query can be invoked at the resource type level for any given resource type level (e.g. without needing to choose a specific resource id for the context).",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.instance",
"path": "OperationDefinition.instance",
"short": "Invoke on an instance?",
"definition": "Indicates whether this operation can be invoked on a particular instance of one of the given types.",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "OperationDefinition.parameter",
"path": "OperationDefinition.parameter",
"short": "Parameters for the operation/query",
"definition": "The parameters for the operation/query.",
"comment": "Query Definitions only have one output parameter, named \"result\". This may not be described, but can be to allow a profile to be defined.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "opd-1",
"severity": "error",
"human": "Either a type must be provided, or parts",
"expression": "type.exists() or part.exists()",
"xpath": "exists(f:type) or exists(f:part)"
},
{
"key": "opd-2",
"severity": "error",
"human": "A search type can only be specified for parameters of type string",
"expression": "searchType implies type = 'string'",
"xpath": "not(exists(f:searchType)) or (f:type/@value = 'string')"
}
]
},
{
"id": "OperationDefinition.parameter.name",
"path": "OperationDefinition.parameter.name",
"short": "Name in Parameters.parameter.name or in URL",
"definition": "The name of used to identify the parameter.",
"comment": "This name must be a token (start with a letter in a..z, and only contain letters, numerals, and underscore. Note that for search parameters (type = string, with a search type), the name may be altered by the search modifiers.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
]
},
{
"id": "OperationDefinition.parameter.use",
"path": "OperationDefinition.parameter.use",
"short": "in | out",
"definition": "Whether this is an input or an output parameter.",
"comment": "If a parameter name is used for both an input and an output parameter, the parameter should be defined twice.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "OperationParameterUse"
}
],
"strength": "required",
"description": "Whether an operation parameter is an input or an output parameter.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/operation-parameter-use"
}
}
},
{
"id": "OperationDefinition.parameter.min",
"path": "OperationDefinition.parameter.min",
"short": "Minimum Cardinality",
"definition": "The minimum number of times this parameter SHALL appear in the request or response.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "OperationDefinition.parameter.max",
"path": "OperationDefinition.parameter.max",
"short": "Maximum Cardinality (a number or *)",
"definition": "The maximum number of times this element is permitted to appear in the request or response.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "OperationDefinition.parameter.documentation",
"path": "OperationDefinition.parameter.documentation",
"short": "Description of meaning/use",
"definition": "Describes the meaning or use of this parameter.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "OperationDefinition.parameter.type",
"path": "OperationDefinition.parameter.type",
"short": "What type this parameter has",
"definition": "The type for this parameter.",
"comment": "if there is no stated parameter, then the parameter is a multi-part parameter; type and must have at least one part defined.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"opd-1"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FHIRAllTypes"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Either an abstract type, a resource or a data type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-types"
}
}
},
{
"id": "OperationDefinition.parameter.searchType",
"path": "OperationDefinition.parameter.searchType",
"short": "number | date | string | token | reference | composite | quantity | uri",
"definition": "How the parameter is understood as a search parameter. This is only used if the parameter type is 'string'.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"opd-2"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SearchParamType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Data types allowed to be used for search parameters.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/search-param-type"
}
}
},
{
"id": "OperationDefinition.parameter.profile",
"path": "OperationDefinition.parameter.profile",
"short": "Profile on the type",
"definition": "A profile the specifies the rules that this parameter must conform to.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/StructureDefinition"
}
]
},
{
"id": "OperationDefinition.parameter.binding",
"path": "OperationDefinition.parameter.binding",
"short": "ValueSet details if this is coded",
"definition": "Binds to a value set if this parameter is coded (code, Coding, CodeableConcept).",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "OperationDefinition.parameter.binding.strength",
"path": "OperationDefinition.parameter.binding.strength",
"short": "required | extensible | preferred | example",
"definition": "Indicates the degree of conformance expectations associated with this binding - that is, the degree to which the provided value set must be adhered to in the instances.",
"comment": "For further discussion, see [Using Terminologies](terminologies.html).",
"alias": [
"conformance",
"extensibility"
],
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "BindingStrength"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Indication of the degree of conformance expectations associated with a binding.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/binding-strength"
}
}
},
{
"id": "OperationDefinition.parameter.binding.valueSet[x]",
"path": "OperationDefinition.parameter.binding.valueSet[x]",
"short": "Source of value set",
"definition": "Points to the value set or external definition (e.g. implicit value set) that identifies the set of codes to be used.",
"comment": "For value sets with a referenceResource, the display can contain the value set description. The reference may be version-specific or not.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ValueSet"
}
]
},
{
"id": "OperationDefinition.parameter.part",
"path": "OperationDefinition.parameter.part",
"short": "Parts of a nested Parameter",
"definition": "The parts of a nested Parameter.",
"comment": "Query Definitions only have one output parameter, named \"result\". This may not be described, but can be to allow a profile to be defined.",
"min": 0,
"max": "*",
"contentReference": "#OperationDefinition.parameter",
"condition": [
"opd-1"
]
},
{
"id": "OperationDefinition.overload",
"path": "OperationDefinition.overload",
"short": "Define overloaded variants for when generating code",
"definition": "Defines an appropriate combination of parameters to use when invoking this operation, to help code generators when generating overloaded parameter sets for this operation.",
"comment": "The combinations are suggestions as to which sets of parameters to use together, but the combinations are not intended to be authoritative.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "OperationDefinition.overload.parameterName",
"path": "OperationDefinition.overload.parameterName",
"short": "Name of parameter to include in overload",
"definition": "Name of parameter to include in overload.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
]
},
{
"id": "OperationDefinition.overload.comment",
"path": "OperationDefinition.overload.comment",
"short": "Comments to go on overload",
"definition": "Comments to go on overload.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/OperationOutcome",
"resource": {
"resourceType": "StructureDefinition",
"id": "OperationOutcome",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints OperationOutcome Σ DomainResource Information about the success/failure of an action
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension issue Σ 1..* BackboneElement A single issue associated with the action
severity ?!Σ 1..1 code fatal | error | warning | information
IssueSeverity (Required) code Σ 1..1 code Error or warning code
IssueType (Required) details Σ 0..1 CodeableConcept Additional details about the error
Operation Outcome Codes (Example) diagnostics Σ 0..1 string Additional diagnostic information about the issue location Σ 0..* string Path of element(s) related to issue
expression Σ 0..* string FHIRPath of element(s) related to issue
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 5
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/OperationOutcome",
"name": "OperationOutcome",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for OperationOutcome Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "OperationOutcome",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "OperationOutcome",
"path": "OperationOutcome",
"short": "Information about the success/failure of an action",
"definition": "A collection of error, warning or information messages that result from a system action.",
"comment": "Can result from the failure of a REST call or be part of the response message returned from a request message. If sent with extensions overriding particular issues, might even appear as part of a request message.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "Grouping is handled through multiple repetitions from whatever context references the outcomes (no specific grouper required)"
},
{
"identity": "w5",
"map": "infrastructure.exchange"
}
]
},
{
"id": "OperationOutcome.id",
"path": "OperationOutcome.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "OperationOutcome.meta",
"path": "OperationOutcome.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "OperationOutcome.implicitRules",
"path": "OperationOutcome.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "OperationOutcome.language",
"path": "OperationOutcome.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "OperationOutcome.text",
"path": "OperationOutcome.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "OperationOutcome.contained",
"path": "OperationOutcome.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "OperationOutcome.extension",
"path": "OperationOutcome.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "OperationOutcome.modifierExtension",
"path": "OperationOutcome.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "OperationOutcome.issue",
"path": "OperationOutcome.issue",
"short": "A single issue associated with the action",
"definition": "An error, warning or information message that results from a system action.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ERR"
},
{
"identity": "rim",
"map": "AcknowledgementDetail or Observation[classCode=\"ALRT\" and moodCode=\"EVN\"]"
}
]
},
{
"id": "OperationOutcome.issue.id",
"path": "OperationOutcome.issue.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "OperationOutcome.issue.extension",
"path": "OperationOutcome.issue.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "OperationOutcome.issue.modifierExtension",
"path": "OperationOutcome.issue.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "OperationOutcome.issue.severity",
"path": "OperationOutcome.issue.severity",
"short": "fatal | error | warning | information",
"definition": "Indicates whether the issue indicates a variation from successful processing.",
"comment": "This is labeled as \"Is Modifier\" because applications should not confuse hints and warnings with errors.",
"requirements": "Indicates how relevant the issue is to the overall success of the action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "IssueSeverity"
}
],
"strength": "required",
"description": "How the issue affects the success of the action.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/issue-severity"
}
},
"mapping": [
{
"identity": "v2",
"map": "ERR-4"
},
{
"identity": "rim",
"map": "./typeCode[parent::AcknowledgmentDetail] or unique(./inboundRelationship[parent::Observation and typeCode='SUBJ' and isNormalActRelationship()]/source[classCode=\"OBS\" and moodCode=\"EVN\" and implies(code, ActCode#SEV and isNormalAct())/value[xsi:type=\"CD\"]"
}
]
},
{
"id": "OperationOutcome.issue.code",
"path": "OperationOutcome.issue.code",
"short": "Error or warning code",
"definition": "Describes the type of the issue. The system that creates an OperationOutcome SHALL choose the most applicable code from the IssueType value set, and may additional provide its own code for the error in the details element.",
"requirements": "Expresses the issue in a human and computer-friendly way, allowing the requesting system to behave differently based on the type of issue.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "IssueType"
}
],
"strength": "required",
"description": "A code that describes the type of issue.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/issue-type"
}
},
"mapping": [
{
"identity": "v2",
"map": "ERR-3"
},
{
"identity": "rim",
"map": "./code"
}
]
},
{
"id": "OperationOutcome.issue.details",
"path": "OperationOutcome.issue.details",
"short": "Additional details about the error",
"definition": "Additional details about the error. This may be a text description of the error, or a system code that identifies the error.",
"comment": "A human readable description of the error issue SHOULD be placed in details.text.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "IssueDetails"
}
],
"strength": "example",
"description": "A code that provides details as the exact issue.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/operation-outcome"
}
},
"mapping": [
{
"identity": "v2",
"map": "ERR-5"
},
{
"identity": "rim",
"map": "./code"
}
]
},
{
"id": "OperationOutcome.issue.diagnostics",
"path": "OperationOutcome.issue.diagnostics",
"short": "Additional diagnostic information about the issue",
"definition": "Additional diagnostic information about the issue. Typically, this may be a description of how a value is erroneous, or a stack dump to help trace the issue.",
"comment": "Typically this field is used to provide troubleshooting information about the error.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ERR-8"
},
{
"identity": "rim",
"map": "./text[parent::AcknowledgmentDetail]"
}
]
},
{
"id": "OperationOutcome.issue.location",
"path": "OperationOutcome.issue.location",
"short": "Path of element(s) related to issue",
"definition": "For resource issues, this will be a simple XPath limited to element names, repetition indicators and the default child access that identifies one of the elements in the resource that caused this issue to be raised. For HTTP errors, will be \"http.\" + the parameter name.",
"comment": "The root of the XPath is the resource or bundle that generated OperationOutcome. Each XPath SHALL resolve to a single node. The XPath syntax is used whether the referenced instance is expressed in XML or JSON. Note that expression is being trialed as an alternative to XPath.",
"requirements": "Allows systems to highlight or otherwise guide users to elements implicated in issues to allow them to be fixed more easily.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ERR-2"
},
{
"identity": "rim",
"map": "./location[parent::AcknowledgmentDetail]"
}
]
},
{
"id": "OperationOutcome.issue.expression",
"path": "OperationOutcome.issue.expression",
"short": "FHIRPath of element(s) related to issue",
"definition": "A simple FHIRPath limited to element names, repetition indicators and the default child access that identifies one of the elements in the resource that caused this issue to be raised.",
"comment": "The root of the FHIRPath is the resource or bundle that generated OperationOutcome. Each FHIRPath SHALL resolve to a single node.",
"requirements": "Allows systems to highlight or otherwise guide users to elements implicated in issues to allow them to be fixed more easily.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ERR-2"
},
{
"identity": "rim",
"map": "./location[parent::AcknowledgmentDetail]"
}
]
}
]
},
"differential": {
"element": [
{
"id": "OperationOutcome",
"path": "OperationOutcome",
"short": "Information about the success/failure of an action",
"definition": "A collection of error, warning or information messages that result from a system action.",
"comment": "Can result from the failure of a REST call or be part of the response message returned from a request message. If sent with extensions overriding particular issues, might even appear as part of a request message.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "Grouping is handled through multiple repetitions from whatever context references the outcomes (no specific grouper required)"
},
{
"identity": "w5",
"map": "infrastructure.exchange"
}
]
},
{
"id": "OperationOutcome.issue",
"path": "OperationOutcome.issue",
"short": "A single issue associated with the action",
"definition": "An error, warning or information message that results from a system action.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ERR"
},
{
"identity": "rim",
"map": "AcknowledgementDetail or Observation[classCode=\"ALRT\" and moodCode=\"EVN\"]"
}
]
},
{
"id": "OperationOutcome.issue.severity",
"path": "OperationOutcome.issue.severity",
"short": "fatal | error | warning | information",
"definition": "Indicates whether the issue indicates a variation from successful processing.",
"comment": "This is labeled as \"Is Modifier\" because applications should not confuse hints and warnings with errors.",
"requirements": "Indicates how relevant the issue is to the overall success of the action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "IssueSeverity"
}
],
"strength": "required",
"description": "How the issue affects the success of the action.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/issue-severity"
}
},
"mapping": [
{
"identity": "v2",
"map": "ERR-4"
},
{
"identity": "rim",
"map": "./typeCode[parent::AcknowledgmentDetail] or unique(./inboundRelationship[parent::Observation and typeCode='SUBJ' and isNormalActRelationship()]/source[classCode=\"OBS\" and moodCode=\"EVN\" and implies(code, ActCode#SEV and isNormalAct())/value[xsi:type=\"CD\"]"
}
]
},
{
"id": "OperationOutcome.issue.code",
"path": "OperationOutcome.issue.code",
"short": "Error or warning code",
"definition": "Describes the type of the issue. The system that creates an OperationOutcome SHALL choose the most applicable code from the IssueType value set, and may additional provide its own code for the error in the details element.",
"requirements": "Expresses the issue in a human and computer-friendly way, allowing the requesting system to behave differently based on the type of issue.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "IssueType"
}
],
"strength": "required",
"description": "A code that describes the type of issue.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/issue-type"
}
},
"mapping": [
{
"identity": "v2",
"map": "ERR-3"
},
{
"identity": "rim",
"map": "./code"
}
]
},
{
"id": "OperationOutcome.issue.details",
"path": "OperationOutcome.issue.details",
"short": "Additional details about the error",
"definition": "Additional details about the error. This may be a text description of the error, or a system code that identifies the error.",
"comment": "A human readable description of the error issue SHOULD be placed in details.text.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "IssueDetails"
}
],
"strength": "example",
"description": "A code that provides details as the exact issue.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/operation-outcome"
}
},
"mapping": [
{
"identity": "v2",
"map": "ERR-5"
},
{
"identity": "rim",
"map": "./code"
}
]
},
{
"id": "OperationOutcome.issue.diagnostics",
"path": "OperationOutcome.issue.diagnostics",
"short": "Additional diagnostic information about the issue",
"definition": "Additional diagnostic information about the issue. Typically, this may be a description of how a value is erroneous, or a stack dump to help trace the issue.",
"comment": "Typically this field is used to provide troubleshooting information about the error.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ERR-8"
},
{
"identity": "rim",
"map": "./text[parent::AcknowledgmentDetail]"
}
]
},
{
"id": "OperationOutcome.issue.location",
"path": "OperationOutcome.issue.location",
"short": "Path of element(s) related to issue",
"definition": "For resource issues, this will be a simple XPath limited to element names, repetition indicators and the default child access that identifies one of the elements in the resource that caused this issue to be raised. For HTTP errors, will be \"http.\" + the parameter name.",
"comment": "The root of the XPath is the resource or bundle that generated OperationOutcome. Each XPath SHALL resolve to a single node. The XPath syntax is used whether the referenced instance is expressed in XML or JSON. Note that expression is being trialed as an alternative to XPath.",
"requirements": "Allows systems to highlight or otherwise guide users to elements implicated in issues to allow them to be fixed more easily.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ERR-2"
},
{
"identity": "rim",
"map": "./location[parent::AcknowledgmentDetail]"
}
]
},
{
"id": "OperationOutcome.issue.expression",
"path": "OperationOutcome.issue.expression",
"short": "FHIRPath of element(s) related to issue",
"definition": "A simple FHIRPath limited to element names, repetition indicators and the default child access that identifies one of the elements in the resource that caused this issue to be raised.",
"comment": "The root of the FHIRPath is the resource or bundle that generated OperationOutcome. Each FHIRPath SHALL resolve to a single node.",
"requirements": "Allows systems to highlight or otherwise guide users to elements implicated in issues to allow them to be fixed more easily.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ERR-2"
},
{
"identity": "rim",
"map": "./location[parent::AcknowledgmentDetail]"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Organization",
"resource": {
"resourceType": "StructureDefinition",
"id": "Organization",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Organization I DomainResource A grouping of people or organizations with a common purpose
+ The organization SHALL at least have a name or an id, and possibly more than one
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier ΣI 0..* Identifier Identifies this organization across multiple systems
active ?!Σ 0..1 boolean Whether the organization's record is still in active use type Σ 0..* CodeableConcept Kind of organization
OrganizationType (Example)
name ΣI 0..1 string Name used for the organization alias 0..* string A list of alternate names that the organization is known as, or was known as in the past
telecom I 0..* ContactPoint A contact detail for the organization
+ The telecom of an organization can never be of use 'home'
address I 0..* Address An address for the organization
+ An address of an organization can never be of use 'home'
partOf Σ 0..1 Reference(Organization) The organization of which this organization forms a part contact 0..* BackboneElement Contact for the organization for a certain purpose
purpose 0..1 CodeableConcept The type of contact
ContactEntityType (Extensible) name 0..1 HumanName A name associated with the contact telecom 0..* ContactPoint Contact details (telephone, email, etc.) for a contact
address 0..1 Address Visiting or postal addresses for the contact endpoint 0..* Reference(Endpoint) Technical endpoints providing access to services operated for the organization
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "pa"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Organization",
"name": "Organization",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Patient Administration)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/pafm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Organization Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "servd",
"uri": "http://www.omg.org/spec/ServD/1.0/",
"name": "ServD"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Organization",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Organization",
"path": "Organization",
"short": "A grouping of people or organizations with a common purpose",
"definition": "A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action. Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, etc.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "org-1",
"severity": "error",
"human": "The organization SHALL at least have a name or an id, and possibly more than one",
"expression": "(identifier.count() + name.count()) > 0",
"xpath": "count(f:identifier | f:name) > 0"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "v2",
"map": "(also see master files messages)"
},
{
"identity": "rim",
"map": "Organization(classCode=ORG, determinerCode=INST)"
},
{
"identity": "servd",
"map": "Organization"
},
{
"identity": "w5",
"map": "administrative.group"
}
]
},
{
"id": "Organization.id",
"path": "Organization.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Organization.meta",
"path": "Organization.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Organization.implicitRules",
"path": "Organization.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Organization.language",
"path": "Organization.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Organization.text",
"path": "Organization.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Organization.contained",
"path": "Organization.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Organization.extension",
"path": "Organization.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Organization.modifierExtension",
"path": "Organization.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Organization.identifier",
"path": "Organization.identifier",
"short": "Identifies this organization across multiple systems",
"definition": "Identifier for the organization that is used to identify the organization across multiple disparate systems.",
"requirements": "Organizations are known by a variety of ids. Some institutions maintain several, and most collect identifiers for exchange with other organizations concerning the organization.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"condition": [
"org-1"
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "XON.10 / XON.3"
},
{
"identity": "rim",
"map": ".scopes[Role](classCode=IDENT)"
},
{
"identity": "servd",
"map": "./Identifiers"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Organization.active",
"path": "Organization.active",
"short": "Whether the organization's record is still in active use",
"definition": "Whether the organization's record is still in active use.",
"comment": "Default is true.\n\nThis active flag is not intended to be used to mark an organizations as temporarily closed or under construction. Instead the Location(s) within the Organization should have the suspended status. If further details of the reason for the suspension are required, then an extension on this element should be used.\n\nThis element is labeled as a modifier because it may be used to mark that the resource was created in error.",
"requirements": "Need a flag to indicate a record is no longer to be used and should generally be hidden for the user in the UI.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "No equivalent in HL7 v2"
},
{
"identity": "rim",
"map": ".status"
},
{
"identity": "servd",
"map": "./Status (however this concept in ServD more covers why the organization is active or not, could be delisted, deregistered, not operational yet) this could alternatively be derived from ./StartDate and ./EndDate and given a context date."
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Organization.type",
"path": "Organization.type",
"short": "Kind of organization",
"definition": "The kind(s) of organization that this is.",
"comment": "Organizations can be corporations, wards, sections, clinical teams, government departments, etc. Note that code is generally a classifier of the type of organization; in many applications, codes are used to identity a particular organization (say, ward) as opposed to another of the same type - these are identifiers, not codes\n\nWhen considering if multiple types are appropriate, you should evaluate if child organizations would be a more appropriate use of the concept, as different types likely are in different sub-areas of the organization. This is most likely to be used where type values have orthogonal values, such as a religious, academic and medical center.\n\nWe expect that some jurisdictions will profile this optionality to be a single cardinality.",
"requirements": "Need to be able to track the kind of organization that this is - different organization types have different uses.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "OrganizationType"
}
],
"strength": "example",
"description": "Used to categorize the organization",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/organization-type"
}
},
"mapping": [
{
"identity": "v2",
"map": "No equivalent in v2"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "servd",
"map": "n/a"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Organization.name",
"path": "Organization.name",
"short": "Name used for the organization",
"definition": "A name associated with the organization.",
"comment": "If the name of an organization changes, consider putting the old name in the alias column so that it can still be located through searches.",
"requirements": "Need to use the name as the label of the organization.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"org-1"
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "XON.1"
},
{
"identity": "rim",
"map": ".name"
},
{
"identity": "servd",
"map": ".PreferredName/Name"
}
]
},
{
"id": "Organization.alias",
"path": "Organization.alias",
"short": "A list of alternate names that the organization is known as, or was known as in the past",
"definition": "A list of alternate names that the organization is known as, or was known as in the past.",
"comment": "There are no dates associated with the alias/historic names, as this is not intended to track when names were used, but to assist in searching so that older names can still result in identifying the organization.",
"requirements": "Over time locations and organizations go through many changes and can be known by different names.\n\nFor searching knowing previous names that the organization was known by can be very useful.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".name"
}
]
},
{
"id": "Organization.telecom",
"path": "Organization.telecom",
"short": "A contact detail for the organization",
"definition": "A contact detail for the organization.",
"comment": "The use code home is not to be used. Note that these contacts are not the contact details of people who are employed by or represent the organization, but official contacts for the organization itself.",
"requirements": "Human contact for the organization.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"condition": [
"org-3"
],
"constraint": [
{
"key": "org-3",
"severity": "error",
"human": "The telecom of an organization can never be of use 'home'",
"expression": "where(use = 'home').empty()",
"xpath": "count(f:use[@value='home']) = 0"
}
],
"mapping": [
{
"identity": "v2",
"map": "ORC-22?"
},
{
"identity": "rim",
"map": ".telecom"
},
{
"identity": "servd",
"map": "./ContactPoints"
}
]
},
{
"id": "Organization.address",
"path": "Organization.address",
"short": "An address for the organization",
"definition": "An address for the organization.",
"comment": "Organization may have multiple addresses with different uses or applicable periods. The use code home is not to be used.",
"requirements": "May need to keep track of the organization's addresses for contacting, billing or reporting requirements.",
"min": 0,
"max": "*",
"type": [
{
"code": "Address"
}
],
"condition": [
"org-2"
],
"constraint": [
{
"key": "org-2",
"severity": "error",
"human": "An address of an organization can never be of use 'home'",
"expression": "where(use = 'home').empty()",
"xpath": "count(f:use[@value='home']) = 0"
}
],
"mapping": [
{
"identity": "v2",
"map": "ORC-23?"
},
{
"identity": "rim",
"map": ".address"
},
{
"identity": "servd",
"map": "./PrimaryAddress and ./OtherAddresses"
}
]
},
{
"id": "Organization.partOf",
"path": "Organization.partOf",
"short": "The organization of which this organization forms a part",
"definition": "The organization of which this organization forms a part.",
"requirements": "Need to be able to track the hierarchy of organizations within an organization.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "No equivalent in HL7 v2"
},
{
"identity": "rim",
"map": ".playedBy[classCode=Part].scoper"
},
{
"identity": "servd",
"map": "n/a"
}
]
},
{
"id": "Organization.contact",
"path": "Organization.contact",
"short": "Contact for the organization for a certain purpose",
"definition": "Contact for the organization for a certain purpose.",
"comment": "Where multiple contacts for the same purpose are provided there is a standard extension that can be used to determine which one is the preferred contact to use.",
"requirements": "Need to keep track of assigned contact points within bigger organization.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".contactParty"
}
]
},
{
"id": "Organization.contact.id",
"path": "Organization.contact.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Organization.contact.extension",
"path": "Organization.contact.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Organization.contact.modifierExtension",
"path": "Organization.contact.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Organization.contact.purpose",
"path": "Organization.contact.purpose",
"short": "The type of contact",
"definition": "Indicates a purpose for which the contact can be reached.",
"requirements": "Need to distinguish between multiple contact persons.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ContactPartyType"
}
],
"strength": "extensible",
"description": "The purpose for which you would contact a contact party",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/contactentity-type"
}
},
"mapping": [
{
"identity": "rim",
"map": "./type"
}
]
},
{
"id": "Organization.contact.name",
"path": "Organization.contact.name",
"short": "A name associated with the contact",
"definition": "A name associated with the contact.",
"requirements": "Need to be able to track the person by name.",
"min": 0,
"max": "1",
"type": [
{
"code": "HumanName"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-5, PID-9"
},
{
"identity": "rim",
"map": "./name"
}
]
},
{
"id": "Organization.contact.telecom",
"path": "Organization.contact.telecom",
"short": "Contact details (telephone, email, etc.) for a contact",
"definition": "A contact detail (e.g. a telephone number or an email address) by which the party may be contacted.",
"requirements": "People have (primary) ways to contact them in some way such as phone, email.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-13, PID-14"
},
{
"identity": "rim",
"map": "./telecom"
}
]
},
{
"id": "Organization.contact.address",
"path": "Organization.contact.address",
"short": "Visiting or postal addresses for the contact",
"definition": "Visiting or postal addresses for the contact.",
"requirements": "May need to keep track of a contact party's address for contacting, billing or reporting requirements.",
"min": 0,
"max": "1",
"type": [
{
"code": "Address"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-11"
},
{
"identity": "rim",
"map": "./addr"
}
]
},
{
"id": "Organization.endpoint",
"path": "Organization.endpoint",
"short": "Technical endpoints providing access to services operated for the organization",
"definition": "Technical endpoints providing access to services operated for the organization.",
"requirements": "Organizations have multiple systems that provide various services and need to be able to define the technical connection details for how to connect to them, and for what purpose.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Endpoint"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Organization",
"path": "Organization",
"short": "A grouping of people or organizations with a common purpose",
"definition": "A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action. Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, etc.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "org-1",
"severity": "error",
"human": "The organization SHALL at least have a name or an id, and possibly more than one",
"expression": "(identifier.count() + name.count()) > 0",
"xpath": "count(f:identifier | f:name) > 0"
}
],
"mapping": [
{
"identity": "v2",
"map": "(also see master files messages)"
},
{
"identity": "rim",
"map": "Organization(classCode=ORG, determinerCode=INST)"
},
{
"identity": "servd",
"map": "Organization"
},
{
"identity": "w5",
"map": "administrative.group"
}
]
},
{
"id": "Organization.identifier",
"path": "Organization.identifier",
"short": "Identifies this organization across multiple systems",
"definition": "Identifier for the organization that is used to identify the organization across multiple disparate systems.",
"requirements": "Organizations are known by a variety of ids. Some institutions maintain several, and most collect identifiers for exchange with other organizations concerning the organization.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"condition": [
"org-1"
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "XON.10 / XON.3"
},
{
"identity": "rim",
"map": ".scopes[Role](classCode=IDENT)"
},
{
"identity": "servd",
"map": "./Identifiers"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Organization.active",
"path": "Organization.active",
"short": "Whether the organization's record is still in active use",
"definition": "Whether the organization's record is still in active use.",
"comment": "Default is true.\n\nThis active flag is not intended to be used to mark an organizations as temporarily closed or under construction. Instead the Location(s) within the Organization should have the suspended status. If further details of the reason for the suspension are required, then an extension on this element should be used.\n\nThis element is labeled as a modifier because it may be used to mark that the resource was created in error.",
"requirements": "Need a flag to indicate a record is no longer to be used and should generally be hidden for the user in the UI.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "No equivalent in HL7 v2"
},
{
"identity": "rim",
"map": ".status"
},
{
"identity": "servd",
"map": "./Status (however this concept in ServD more covers why the organization is active or not, could be delisted, deregistered, not operational yet) this could alternatively be derived from ./StartDate and ./EndDate and given a context date."
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Organization.type",
"path": "Organization.type",
"short": "Kind of organization",
"definition": "The kind(s) of organization that this is.",
"comment": "Organizations can be corporations, wards, sections, clinical teams, government departments, etc. Note that code is generally a classifier of the type of organization; in many applications, codes are used to identity a particular organization (say, ward) as opposed to another of the same type - these are identifiers, not codes\n\nWhen considering if multiple types are appropriate, you should evaluate if child organizations would be a more appropriate use of the concept, as different types likely are in different sub-areas of the organization. This is most likely to be used where type values have orthogonal values, such as a religious, academic and medical center.\n\nWe expect that some jurisdictions will profile this optionality to be a single cardinality.",
"requirements": "Need to be able to track the kind of organization that this is - different organization types have different uses.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "OrganizationType"
}
],
"strength": "example",
"description": "Used to categorize the organization",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/organization-type"
}
},
"mapping": [
{
"identity": "v2",
"map": "No equivalent in v2"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "servd",
"map": "n/a"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Organization.name",
"path": "Organization.name",
"short": "Name used for the organization",
"definition": "A name associated with the organization.",
"comment": "If the name of an organization changes, consider putting the old name in the alias column so that it can still be located through searches.",
"requirements": "Need to use the name as the label of the organization.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"org-1"
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "XON.1"
},
{
"identity": "rim",
"map": ".name"
},
{
"identity": "servd",
"map": ".PreferredName/Name"
}
]
},
{
"id": "Organization.alias",
"path": "Organization.alias",
"short": "A list of alternate names that the organization is known as, or was known as in the past",
"definition": "A list of alternate names that the organization is known as, or was known as in the past.",
"comment": "There are no dates associated with the alias/historic names, as this is not intended to track when names were used, but to assist in searching so that older names can still result in identifying the organization.",
"requirements": "Over time locations and organizations go through many changes and can be known by different names.\n\nFor searching knowing previous names that the organization was known by can be very useful.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".name"
}
]
},
{
"id": "Organization.telecom",
"path": "Organization.telecom",
"short": "A contact detail for the organization",
"definition": "A contact detail for the organization.",
"comment": "The use code home is not to be used. Note that these contacts are not the contact details of people who are employed by or represent the organization, but official contacts for the organization itself.",
"requirements": "Human contact for the organization.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"condition": [
"org-3"
],
"constraint": [
{
"key": "org-3",
"severity": "error",
"human": "The telecom of an organization can never be of use 'home'",
"expression": "where(use = 'home').empty()",
"xpath": "count(f:use[@value='home']) = 0"
}
],
"mapping": [
{
"identity": "v2",
"map": "ORC-22?"
},
{
"identity": "rim",
"map": ".telecom"
},
{
"identity": "servd",
"map": "./ContactPoints"
}
]
},
{
"id": "Organization.address",
"path": "Organization.address",
"short": "An address for the organization",
"definition": "An address for the organization.",
"comment": "Organization may have multiple addresses with different uses or applicable periods. The use code home is not to be used.",
"requirements": "May need to keep track of the organization's addresses for contacting, billing or reporting requirements.",
"min": 0,
"max": "*",
"type": [
{
"code": "Address"
}
],
"condition": [
"org-2"
],
"constraint": [
{
"key": "org-2",
"severity": "error",
"human": "An address of an organization can never be of use 'home'",
"expression": "where(use = 'home').empty()",
"xpath": "count(f:use[@value='home']) = 0"
}
],
"mapping": [
{
"identity": "v2",
"map": "ORC-23?"
},
{
"identity": "rim",
"map": ".address"
},
{
"identity": "servd",
"map": "./PrimaryAddress and ./OtherAddresses"
}
]
},
{
"id": "Organization.partOf",
"path": "Organization.partOf",
"short": "The organization of which this organization forms a part",
"definition": "The organization of which this organization forms a part.",
"requirements": "Need to be able to track the hierarchy of organizations within an organization.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "No equivalent in HL7 v2"
},
{
"identity": "rim",
"map": ".playedBy[classCode=Part].scoper"
},
{
"identity": "servd",
"map": "n/a"
}
]
},
{
"id": "Organization.contact",
"path": "Organization.contact",
"short": "Contact for the organization for a certain purpose",
"definition": "Contact for the organization for a certain purpose.",
"comment": "Where multiple contacts for the same purpose are provided there is a standard extension that can be used to determine which one is the preferred contact to use.",
"requirements": "Need to keep track of assigned contact points within bigger organization.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".contactParty"
}
]
},
{
"id": "Organization.contact.purpose",
"path": "Organization.contact.purpose",
"short": "The type of contact",
"definition": "Indicates a purpose for which the contact can be reached.",
"requirements": "Need to distinguish between multiple contact persons.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ContactPartyType"
}
],
"strength": "extensible",
"description": "The purpose for which you would contact a contact party",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/contactentity-type"
}
},
"mapping": [
{
"identity": "rim",
"map": "./type"
}
]
},
{
"id": "Organization.contact.name",
"path": "Organization.contact.name",
"short": "A name associated with the contact",
"definition": "A name associated with the contact.",
"requirements": "Need to be able to track the person by name.",
"min": 0,
"max": "1",
"type": [
{
"code": "HumanName"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-5, PID-9"
},
{
"identity": "rim",
"map": "./name"
}
]
},
{
"id": "Organization.contact.telecom",
"path": "Organization.contact.telecom",
"short": "Contact details (telephone, email, etc.) for a contact",
"definition": "A contact detail (e.g. a telephone number or an email address) by which the party may be contacted.",
"requirements": "People have (primary) ways to contact them in some way such as phone, email.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-13, PID-14"
},
{
"identity": "rim",
"map": "./telecom"
}
]
},
{
"id": "Organization.contact.address",
"path": "Organization.contact.address",
"short": "Visiting or postal addresses for the contact",
"definition": "Visiting or postal addresses for the contact.",
"requirements": "May need to keep track of a contact party's address for contacting, billing or reporting requirements.",
"min": 0,
"max": "1",
"type": [
{
"code": "Address"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-11"
},
{
"identity": "rim",
"map": "./addr"
}
]
},
{
"id": "Organization.endpoint",
"path": "Organization.endpoint",
"short": "Technical endpoints providing access to services operated for the organization",
"definition": "Technical endpoints providing access to services operated for the organization.",
"requirements": "Organizations have multiple systems that provide various services and need to be able to define the technical connection details for how to connect to them, and for what purpose.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Endpoint"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Parameters",
"resource": {
"resourceType": "StructureDefinition",
"id": "Parameters",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Parameters Σ Resource Operation Request or Response
Elements defined in Ancestors: id, meta, implicitRules, language parameter ΣI 0..* BackboneElement Operation Parameter
+ A parameter must have only one of (value, resource, part)
name Σ 1..1 string Name from the definition value[x] ΣI 0..1 * If parameter is a data type resource ΣI 0..1 Resource If parameter is a whole resource part Σ 0..* see parameter Named part of a multi-part parameter
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 5
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Parameters",
"name": "Parameters",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Parameters Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Parameters",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/Resource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Parameters",
"path": "Parameters",
"short": "Operation Request or Response",
"definition": "This special resource type is used to represent an operation request and response (operations.html). It has no other use, and there is no RESTful endpoint associated with it.",
"comment": "The parameters that may be used are defined by the OperationDefinition resource.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "v2",
"map": "n/a"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "infrastructure.exchange"
}
]
},
{
"id": "Parameters.id",
"path": "Parameters.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Parameters.meta",
"path": "Parameters.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Parameters.implicitRules",
"path": "Parameters.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Parameters.language",
"path": "Parameters.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Parameters.parameter",
"path": "Parameters.parameter",
"short": "Operation Parameter",
"definition": "A parameter passed to or received from the operation.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "inv-1",
"severity": "error",
"human": "A parameter must have only one of (value, resource, part)",
"expression": "(part.exists() and value.empty() and resource.empty()) or (part.empty() and (value.exists() xor resource.exists()))",
"xpath": "exists(f:value) or exists(f:resource) and not(exists(f:value) and exists(f:resource))"
}
],
"isSummary": true
},
{
"id": "Parameters.parameter.id",
"path": "Parameters.parameter.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Parameters.parameter.extension",
"path": "Parameters.parameter.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Parameters.parameter.modifierExtension",
"path": "Parameters.parameter.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Parameters.parameter.name",
"path": "Parameters.parameter.name",
"short": "Name from the definition",
"definition": "The name of the parameter (reference to the operation definition).",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Parameters.parameter.value[x]",
"path": "Parameters.parameter.value[x]",
"short": "If parameter is a data type",
"definition": "If the parameter is a data type.",
"min": 0,
"max": "1",
"type": [
{
"code": "base64Binary"
},
{
"code": "boolean"
},
{
"code": "code"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "decimal"
},
{
"code": "id"
},
{
"code": "instant"
},
{
"code": "integer"
},
{
"code": "markdown"
},
{
"code": "oid"
},
{
"code": "positiveInt"
},
{
"code": "string"
},
{
"code": "time"
},
{
"code": "unsignedInt"
},
{
"code": "uri"
},
{
"code": "Address"
},
{
"code": "Age"
},
{
"code": "Annotation"
},
{
"code": "Attachment"
},
{
"code": "CodeableConcept"
},
{
"code": "Coding"
},
{
"code": "ContactPoint"
},
{
"code": "Count"
},
{
"code": "Distance"
},
{
"code": "Duration"
},
{
"code": "HumanName"
},
{
"code": "Identifier"
},
{
"code": "Money"
},
{
"code": "Period"
},
{
"code": "Quantity"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "Reference"
},
{
"code": "SampledData"
},
{
"code": "Signature"
},
{
"code": "Timing"
},
{
"code": "Meta"
}
],
"condition": [
"inv-1"
],
"isSummary": true
},
{
"id": "Parameters.parameter.resource",
"path": "Parameters.parameter.resource",
"short": "If parameter is a whole resource",
"definition": "If the parameter is a whole resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "Resource"
}
],
"condition": [
"inv-1"
],
"isSummary": true
},
{
"id": "Parameters.parameter.part",
"path": "Parameters.parameter.part",
"short": "Named part of a multi-part parameter",
"definition": "A named part of a multi-part parameter.",
"comment": "Only one level of nested parameters is allowed.",
"min": 0,
"max": "*",
"contentReference": "#Parameters.parameter",
"isSummary": true
}
]
},
"differential": {
"element": [
{
"id": "Parameters",
"path": "Parameters",
"short": "Operation Request or Response",
"definition": "This special resource type is used to represent an operation request and response (operations.html). It has no other use, and there is no RESTful endpoint associated with it.",
"comment": "The parameters that may be used are defined by the OperationDefinition resource.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "v2",
"map": "n/a"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "infrastructure.exchange"
}
]
},
{
"id": "Parameters.parameter",
"path": "Parameters.parameter",
"short": "Operation Parameter",
"definition": "A parameter passed to or received from the operation.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "inv-1",
"severity": "error",
"human": "A parameter must have only one of (value, resource, part)",
"expression": "(part.exists() and value.empty() and resource.empty()) or (part.empty() and (value.exists() xor resource.exists()))",
"xpath": "exists(f:value) or exists(f:resource) and not(exists(f:value) and exists(f:resource))"
}
],
"isSummary": true
},
{
"id": "Parameters.parameter.name",
"path": "Parameters.parameter.name",
"short": "Name from the definition",
"definition": "The name of the parameter (reference to the operation definition).",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Parameters.parameter.value[x]",
"path": "Parameters.parameter.value[x]",
"short": "If parameter is a data type",
"definition": "If the parameter is a data type.",
"min": 0,
"max": "1",
"type": [
{
"code": "base64Binary"
},
{
"code": "boolean"
},
{
"code": "code"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "decimal"
},
{
"code": "id"
},
{
"code": "instant"
},
{
"code": "integer"
},
{
"code": "markdown"
},
{
"code": "oid"
},
{
"code": "positiveInt"
},
{
"code": "string"
},
{
"code": "time"
},
{
"code": "unsignedInt"
},
{
"code": "uri"
},
{
"code": "Address"
},
{
"code": "Age"
},
{
"code": "Annotation"
},
{
"code": "Attachment"
},
{
"code": "CodeableConcept"
},
{
"code": "Coding"
},
{
"code": "ContactPoint"
},
{
"code": "Count"
},
{
"code": "Distance"
},
{
"code": "Duration"
},
{
"code": "HumanName"
},
{
"code": "Identifier"
},
{
"code": "Money"
},
{
"code": "Period"
},
{
"code": "Quantity"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "Reference"
},
{
"code": "SampledData"
},
{
"code": "Signature"
},
{
"code": "Timing"
},
{
"code": "Meta"
}
],
"condition": [
"inv-1"
],
"isSummary": true
},
{
"id": "Parameters.parameter.resource",
"path": "Parameters.parameter.resource",
"short": "If parameter is a whole resource",
"definition": "If the parameter is a whole resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "Resource"
}
],
"condition": [
"inv-1"
],
"isSummary": true
},
{
"id": "Parameters.parameter.part",
"path": "Parameters.parameter.part",
"short": "Named part of a multi-part parameter",
"definition": "A named part of a multi-part parameter.",
"comment": "Only one level of nested parameters is allowed.",
"min": 0,
"max": "*",
"contentReference": "#Parameters.parameter",
"isSummary": true
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Patient",
"resource": {
"resourceType": "StructureDefinition",
"id": "Patient",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Patient DomainResource Information about an individual or animal receiving health care services
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier An identifier for this patient
active ?!Σ 0..1 boolean Whether this patient's record is in active use name Σ 0..* HumanName A name associated with the patient
telecom Σ 0..* ContactPoint A contact detail for the individual
gender Σ 0..1 code male | female | other | unknown
AdministrativeGender (Required) birthDate Σ 0..1 date The date of birth for the individual deceased[x] ?!Σ 0..1 Indicates if the individual is deceased or not deceasedBoolean boolean deceasedDateTime dateTime address Σ 0..* Address Addresses for the individual
maritalStatus 0..1 CodeableConcept Marital (civil) status of a patient
Marital Status Codes (Extensible) multipleBirth[x] 0..1 Whether patient is part of a multiple birth multipleBirthBoolean boolean multipleBirthInteger integer photo 0..* Attachment Image of the patient
contact I 0..* BackboneElement A contact party (e.g. guardian, partner, friend) for the patient
+ SHALL at least contain a contact's details or a reference to an organization
relationship 0..* CodeableConcept The kind of relationship
v2 Contact Role (Extensible)
name 0..1 HumanName A name associated with the contact person telecom 0..* ContactPoint A contact detail for the person
address 0..1 Address Address for the contact person gender 0..1 code male | female | other | unknown
AdministrativeGender (Required) organization I 0..1 Reference(Organization) Organization that is associated with the contact period 0..1 Period The period during which this contact person or organization is valid to be contacted relating to this patient animal ?!Σ 0..1 BackboneElement This patient is known to be an animal (non-human) species Σ 1..1 CodeableConcept E.g. Dog, Cow
AnimalSpecies (Example) breed Σ 0..1 CodeableConcept E.g. Poodle, Angus
AnimalBreeds (Example) genderStatus Σ 0..1 CodeableConcept E.g. Neutered, Intact
GenderStatus (Example) communication 0..* BackboneElement A list of Languages which may be used to communicate with the patient about his or her health
language 1..1 CodeableConcept The language which can be used to communicate with the patient about his or her health
Common Languages (Extensible but limited to All Languages) preferred 0..1 boolean Language preference indicator generalPractitioner 0..* Reference(Organization | Practitioner) Patient's nominated primary care provider
managingOrganization Σ 0..1 Reference(Organization) Organization that is the custodian of the patient record link ?!Σ 0..* BackboneElement Link to another patient resource that concerns the same actual person
other Σ 1..1 Reference(Patient | RelatedPerson) The other patient or related person resource that the link refers to type Σ 1..1 code replaced-by | replaces | refer | seealso - type of link
LinkType (Required)
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 5
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "pa"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Patient",
"name": "Patient",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Patient Administration)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/pafm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Patient Resource",
"purpose": "Tracking patient is the center of the healthcare process.",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "cda",
"uri": "http://hl7.org/v3/cda",
"name": "CDA (R2)"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "loinc",
"uri": "http://loinc.org",
"name": "LOINC code for the element"
}
],
"kind": "resource",
"abstract": false,
"type": "Patient",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Patient",
"path": "Patient",
"short": "Information about an individual or animal receiving health care services",
"definition": "Demographics and other administrative information about an individual or animal receiving care or other health-related services.",
"alias": [
"SubjectOfCare Client Resident"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "Patient[classCode=PAT]"
},
{
"identity": "cda",
"map": "ClinicalDocument.recordTarget.patientRole"
},
{
"identity": "w5",
"map": "administrative.individual"
}
]
},
{
"id": "Patient.id",
"path": "Patient.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Patient.meta",
"path": "Patient.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Patient.implicitRules",
"path": "Patient.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Patient.language",
"path": "Patient.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Patient.text",
"path": "Patient.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Patient.contained",
"path": "Patient.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Patient.extension",
"path": "Patient.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Patient.modifierExtension",
"path": "Patient.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Patient.identifier",
"path": "Patient.identifier",
"short": "An identifier for this patient",
"definition": "An identifier for this patient.",
"requirements": "Patients are almost always assigned specific numerical identifiers.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "rim",
"map": "id"
},
{
"identity": "cda",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Patient.active",
"path": "Patient.active",
"short": "Whether this patient's record is in active use",
"definition": "Whether this patient record is in active use.",
"comment": "Default is true. If a record is inactive, and linked to an active record, then future patient/record updates should occur on the other patient\n\nThis element is labeled as a modifier because when the patient record is marked as not active it is not expected to be used/referenced without being changed back to active.",
"requirements": "Need to be able to mark a patient record as not to be used because it was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "statusCode"
},
{
"identity": "cda",
"map": "n/a"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Patient.name",
"path": "Patient.name",
"short": "A name associated with the patient",
"definition": "A name associated with the individual.",
"comment": "A patient may have multiple names with different uses or applicable periods. For animals, the name is a \"HumanName\" in the sense that is assigned and used by humans and has the same patterns.",
"requirements": "Need to be able to track the patient by multiple names. Examples are your official name and a partner name.",
"min": 0,
"max": "*",
"type": [
{
"code": "HumanName"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-5, PID-9"
},
{
"identity": "rim",
"map": "name"
},
{
"identity": "cda",
"map": ".patient.name"
}
]
},
{
"id": "Patient.telecom",
"path": "Patient.telecom",
"short": "A contact detail for the individual",
"definition": "A contact detail (e.g. a telephone number or an email address) by which the individual may be contacted.",
"comment": "A Patient may have multiple ways to be contacted with different uses or applicable periods. May need to have options for contacting the person urgently and also to help with identification. The address may not go directly to the individual, but may reach another party that is able to proxy for the patient (i.e. home phone, or pet owner's phone).",
"requirements": "People have (primary) ways to contact them in some way such as phone, email.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-13, PID-14, PID-40"
},
{
"identity": "rim",
"map": "telecom"
},
{
"identity": "cda",
"map": ".telecom"
}
]
},
{
"id": "Patient.gender",
"path": "Patient.gender",
"short": "male | female | other | unknown",
"definition": "Administrative Gender - the gender that the patient is considered to have for administration and record keeping purposes.",
"comment": "The gender may not match the biological sex as determined by genetics, or the individual's preferred identification. Note that for both humans and particularly animals, there are other legitimate possibilities than M and F, though the vast majority of systems and contexts only support M and F. Systems providing decision support or enforcing business rules should ideally do this on the basis of Observations dealing with the specific gender aspect of interest (anatomical, chromosonal, social, etc.) However, because these observations are infrequently recorded, defaulting to the administrative gender is common practice. Where such defaulting occurs, rule enforcement should allow for the variation between administrative and biological, chromosonal and other gender aspects. For example, an alert about a hysterectomy on a male should be handled as a warning or overrideable error, not a \"hard\" error.",
"requirements": "Needed for identification of the individual, in combination with (at least) name and birth date. Gender of individual drives many clinical processes.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdministrativeGender"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The gender of a person used for administrative purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administrative-gender"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-8"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/administrativeGender"
},
{
"identity": "cda",
"map": ".patient.administrativeGenderCode"
}
]
},
{
"id": "Patient.birthDate",
"path": "Patient.birthDate",
"short": "The date of birth for the individual",
"definition": "The date of birth for the individual.",
"comment": "At least an estimated year should be provided as a guess if the real DOB is unknown There is a standard extension \"patient-birthTime\" available that should be used where Time is required (such as in maternaty/infant care systems).",
"requirements": "Age of the individual drives many clinical processes.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-7"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/birthTime"
},
{
"identity": "cda",
"map": ".patient.birthTime"
},
{
"identity": "loinc",
"map": "21112-8"
}
]
},
{
"id": "Patient.deceased[x]",
"path": "Patient.deceased[x]",
"short": "Indicates if the individual is deceased or not",
"definition": "Indicates if the individual is deceased or not.",
"comment": "If there's no value in the instance it means there is no statement on whether or not the individual is deceased. Most systems will interpret the absence of a value as a sign of the person being alive.\n\nThis element is labeled as a modifier because once a patient is marked as deceased, the actions that are appropriate to perform on the patient may be significantly different.",
"requirements": "The fact that a patient is deceased influences the clinical process. Also, in human communication and relation management it is necessary to know whether the person is alive.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "dateTime"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-30 (bool) and PID-29 (datetime)"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/deceasedInd, player[classCode=PSN|ANM and determinerCode=INSTANCE]/deceasedTime"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.address",
"path": "Patient.address",
"short": "Addresses for the individual",
"definition": "Addresses for the individual.",
"comment": "Patient may have multiple addresses with different uses or applicable periods.",
"requirements": "May need to keep track of patient addresses for contacting, billing or reporting requirements and also to help with identification.",
"min": 0,
"max": "*",
"type": [
{
"code": "Address"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-11"
},
{
"identity": "rim",
"map": "addr"
},
{
"identity": "cda",
"map": ".addr"
}
]
},
{
"id": "Patient.maritalStatus",
"path": "Patient.maritalStatus",
"short": "Marital (civil) status of a patient",
"definition": "This field contains a patient's most recent marital (civil) status.",
"requirements": "Most, if not all systems capture it.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MaritalStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "The domestic partnership status of a person.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/marital-status"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-16"
},
{
"identity": "rim",
"map": "player[classCode=PSN]/maritalStatusCode"
},
{
"identity": "cda",
"map": ".patient.maritalStatusCode"
}
]
},
{
"id": "Patient.multipleBirth[x]",
"path": "Patient.multipleBirth[x]",
"short": "Whether patient is part of a multiple birth",
"definition": "Indicates whether the patient is part of a multiple (bool) or indicates the actual birth order (integer).",
"comment": "Where the valueInteger is provided, the number is the birth number in the sequence.\nE.g. The middle birth in tripplets would be valueInteger=2 and the third born would have valueInteger=3\nIf a bool value was provided for this tripplets examle, then all 3 patient records would have valueBool=true (the ordering is not indicated).",
"requirements": "For disambiguation of multiple-birth children, especially relevant where the care provider doesn't meet the patient, such as labs.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "integer"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-24 (bool), PID-25 (integer)"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/multipleBirthInd, player[classCode=PSN|ANM and determinerCode=INSTANCE]/multipleBirthOrderNumber"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.photo",
"path": "Patient.photo",
"short": "Image of the patient",
"definition": "Image of the patient.",
"requirements": "Many EHR systems have the capability to capture an image of the patient. Fits with newer social media usage too.",
"min": 0,
"max": "*",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX-5 - needs a profile"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/desc"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Contact"
}
],
"path": "Patient.contact",
"short": "A contact party (e.g. guardian, partner, friend) for the patient",
"definition": "A contact party (e.g. guardian, partner, friend) for the patient.",
"comment": "Contact covers all kinds of contact parties: family members, business contacts, guardians, caregivers. Not applicable to register pedigree and family ties beyond use of having contact.",
"requirements": "Need to track people you can contact about the patient.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "pat-1",
"severity": "error",
"human": "SHALL at least contain a contact's details or a reference to an organization",
"expression": "name.exists() or telecom.exists() or address.exists() or organization.exists()",
"xpath": "exists(f:name) or exists(f:telecom) or exists(f:address) or exists(f:organization)"
}
],
"mapping": [
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/scopedRole[classCode=CON]"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.id",
"path": "Patient.contact.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.extension",
"path": "Patient.contact.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.modifierExtension",
"path": "Patient.contact.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Patient.contact.relationship",
"path": "Patient.contact.relationship",
"short": "The kind of relationship",
"definition": "The nature of the relationship between the patient and the contact person.",
"requirements": "Used to determine which contact person is the most relevant to approach, depending on circumstances.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ContactRelationship"
}
],
"strength": "extensible",
"description": "The nature of the relationship between a patient and a contact person for that patient.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v2-0131"
}
},
"mapping": [
{
"identity": "v2",
"map": "NK1-7, NK1-3"
},
{
"identity": "rim",
"map": "code"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.name",
"path": "Patient.contact.name",
"short": "A name associated with the contact person",
"definition": "A name associated with the contact person.",
"requirements": "Contact persons need to be identified by name, but it is uncommon to need details about multiple other names for that contact person.",
"min": 0,
"max": "1",
"type": [
{
"code": "HumanName"
}
],
"mapping": [
{
"identity": "v2",
"map": "NK1-2"
},
{
"identity": "rim",
"map": "name"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.telecom",
"path": "Patient.contact.telecom",
"short": "A contact detail for the person",
"definition": "A contact detail for the person, e.g. a telephone number or an email address.",
"comment": "Contact may have multiple ways to be contacted with different uses or applicable periods. May need to have options for contacting the person urgently, and also to help with identification.",
"requirements": "People have (primary) ways to contact them in some way such as phone, email.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"mapping": [
{
"identity": "v2",
"map": "NK1-5, NK1-6, NK1-40"
},
{
"identity": "rim",
"map": "telecom"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.address",
"path": "Patient.contact.address",
"short": "Address for the contact person",
"definition": "Address for the contact person.",
"requirements": "Need to keep track where the contact person can be contacted per postal mail or visited.",
"min": 0,
"max": "1",
"type": [
{
"code": "Address"
}
],
"mapping": [
{
"identity": "v2",
"map": "NK1-4"
},
{
"identity": "rim",
"map": "addr"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.gender",
"path": "Patient.contact.gender",
"short": "male | female | other | unknown",
"definition": "Administrative Gender - the gender that the contact person is considered to have for administration and record keeping purposes.",
"requirements": "Needed to address the person correctly.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdministrativeGender"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The gender of a person used for administrative purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administrative-gender"
}
},
"mapping": [
{
"identity": "v2",
"map": "NK1-15"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/administrativeGender"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.organization",
"path": "Patient.contact.organization",
"short": "Organization that is associated with the contact",
"definition": "Organization on behalf of which the contact is acting or for which the contact is working.",
"requirements": "For guardians or business related contacts, the organization is relevant.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"condition": [
"pat-1"
],
"mapping": [
{
"identity": "v2",
"map": "NK1-13, NK1-30, NK1-31, NK1-32, NK1-41"
},
{
"identity": "rim",
"map": "scoper"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.period",
"path": "Patient.contact.period",
"short": "The period during which this contact person or organization is valid to be contacted relating to this patient",
"definition": "The period during which this contact person or organization is valid to be contacted relating to this patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": "effectiveTime"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.animal",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Animal"
}
],
"path": "Patient.animal",
"short": "This patient is known to be an animal (non-human)",
"definition": "This patient is known to be an animal.",
"comment": "The animal element is labeled \"Is Modifier\" since patients may be non-human. Systems SHALL either handle patient details appropriately (e.g. inform users patient is not human) or reject declared animal records. The absense of the animal element does not imply that the patient is a human. If a system requires such a positive assertion that the patient is human, an extension will be required. (Do not use a species of homo-sapiens in animal species, as this would incorrectly infer that the patient is an animal).",
"requirements": "Many clinical systems are extended to care for animal patients as well as human.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "player[classCode=ANM]"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.animal.id",
"path": "Patient.animal.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Patient.animal.extension",
"path": "Patient.animal.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Patient.animal.modifierExtension",
"path": "Patient.animal.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Patient.animal.species",
"path": "Patient.animal.species",
"short": "E.g. Dog, Cow",
"definition": "Identifies the high level taxonomic categorization of the kind of animal.",
"comment": "If the patient is non-human, at least a species SHALL be specified. Species SHALL be a widely recognised taxonomic classification. It may or may not be Linnaean taxonomy and may or may not be at the level of species. If the level is finer than species--such as a breed code--the code system used SHALL allow inference of the species. (The common example is that the word \"Hereford\" does not allow inference of the species Bos taurus, because there is a Hereford pig breed, but the SNOMED CT code for \"Hereford Cattle Breed\" does.).",
"requirements": "Need to know what kind of animal.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AnimalSpecies"
}
],
"strength": "example",
"description": "The species of an animal.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/animal-species"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-35"
},
{
"identity": "rim",
"map": "code"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.animal.breed",
"path": "Patient.animal.breed",
"short": "E.g. Poodle, Angus",
"definition": "Identifies the detailed categorization of the kind of animal.",
"comment": "Breed MAY be used to provide further taxonomic or non-taxonomic classification. It may involve local or proprietary designation--such as commercial strain--and/or additional information such as production type.",
"requirements": "May need to know the specific kind within the species.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AnimalBreed"
}
],
"strength": "example",
"description": "The breed of an animal.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/animal-breeds"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-37"
},
{
"identity": "rim",
"map": "playedRole[classCode=GEN]/scoper[classCode=ANM, determinerCode=KIND]/code"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.animal.genderStatus",
"path": "Patient.animal.genderStatus",
"short": "E.g. Neutered, Intact",
"definition": "Indicates the current state of the animal's reproductive organs.",
"requirements": "Gender status can affect housing and animal behavior.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AnimalGenderStatus"
}
],
"strength": "example",
"description": "The state of the animal's reproductive organs.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/animal-genderstatus"
}
},
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "genderStatusCode"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.communication",
"path": "Patient.communication",
"short": "A list of Languages which may be used to communicate with the patient about his or her health",
"definition": "Languages which may be used to communicate with the patient about his or her health.",
"comment": "If no language is specified, this *implies* that the default local language is spoken. If you need to convey proficiency for multiple modes then you need multiple Patient.Communication associations. For animals, language is not a relevant field, and should be absent from the instance. If the Patient does not speak the default local language, then the Interpreter Required Standard can be used to explicitly declare that an interpreter is required.",
"requirements": "If a patient does not speak the local language, interpreters may be required, so languages spoken and proficiency is an important things to keep track of both for patient and other persons of interest.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": "LanguageCommunication"
},
{
"identity": "cda",
"map": "patient.languageCommunication"
}
]
},
{
"id": "Patient.communication.id",
"path": "Patient.communication.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Patient.communication.extension",
"path": "Patient.communication.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Patient.communication.modifierExtension",
"path": "Patient.communication.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Patient.communication.language",
"path": "Patient.communication.language",
"short": "The language which can be used to communicate with the patient about his or her health",
"definition": "The ISO-639-1 alpha 2 code in lower case for the language, optionally followed by a hyphen and the ISO-3166-1 alpha 2 code for the region in upper case; e.g. \"en\" for English, or \"en-US\" for American English versus \"en-EN\" for England English.",
"comment": "The structure aa-BB with this exact casing is one the most widely used notations for locale. However not all systems actually code this but instead have it as free text. Hence CodeableConcept instead of code as the data type.",
"requirements": "Most systems in multilingual countries will want to convey language. Not all systems actually need the regional dialect.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-15, LAN-2"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/languageCommunication/code"
},
{
"identity": "cda",
"map": ".languageCode"
}
]
},
{
"id": "Patient.communication.preferred",
"path": "Patient.communication.preferred",
"short": "Language preference indicator",
"definition": "Indicates whether or not the patient prefers this language (over other languages he masters up a certain level).",
"comment": "This language is specifically identified for communicating healthcare information.",
"requirements": "People that master multiple languages up to certain level may prefer one or more, i.e. feel more confident in communicating in a particular language making other languages sort of a fall back method.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-15"
},
{
"identity": "rim",
"map": "preferenceInd"
},
{
"identity": "cda",
"map": ".preferenceInd"
}
]
},
{
"id": "Patient.generalPractitioner",
"path": "Patient.generalPractitioner",
"short": "Patient's nominated primary care provider",
"definition": "Patient's nominated care provider.",
"comment": "This may be the primary care provider (in a GP context), or it may be a patient nominated care manager in a community/disablity setting, or even organization that will provide people to perform the care provider roles.\n\nIt is not to be used to record Care Teams, these should be in a CareTeam resource that may be linked to the CarePlan or EpisodeOfCare resources.",
"alias": [
"careProvider"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "v2",
"map": "PD1-4"
},
{
"identity": "rim",
"map": "subjectOf.CareEvent.performer.AssignedEntity"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.managingOrganization",
"path": "Patient.managingOrganization",
"short": "Organization that is the custodian of the patient record",
"definition": "Organization that is the custodian of the patient record.",
"comment": "There is only one managing organization for a specific patient record. Other organizations will have their own Patient record, and may use the Link property to join the records together (or a Person resource which can include confidence ratings for the association).",
"requirements": "Need to know who recognizes this patient record, manages and updates it.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "scoper"
},
{
"identity": "cda",
"map": ".providerOrganization"
}
]
},
{
"id": "Patient.link",
"path": "Patient.link",
"short": "Link to another patient resource that concerns the same actual person",
"definition": "Link to another patient resource that concerns the same actual patient.",
"comment": "There is no assumption that linked patient records have mutual links. \n\nThis element is labelled as a modifier because it may not be the main Patient resource, and the referenced patient should be used instead of this Patient record. This is when the link.type value is 'replaced-by'.",
"requirements": "There are multiple usecases: \n\n* Duplicate patient records due to the clerical errors associated with the difficulties of identifying humans consistently, and * Distribution of patient information across multiple servers.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "outboundLink"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.link.id",
"path": "Patient.link.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Patient.link.extension",
"path": "Patient.link.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Patient.link.modifierExtension",
"path": "Patient.link.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Patient.link.other",
"path": "Patient.link.other",
"short": "The other patient or related person resource that the link refers to",
"definition": "The other patient resource that the link refers to.",
"comment": "Referencing a RelatedPerson here removes the need to use a Person record to associate a Patient and RelatedPerson as the same individual.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-3, MRG-1"
},
{
"identity": "rim",
"map": "id"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.link.type",
"path": "Patient.link.type",
"short": "replaced-by | replaces | refer | seealso - type of link",
"definition": "The type of link between this patient resource and another patient resource.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "LinkType"
}
],
"strength": "required",
"description": "The type of link between this patient resource and another patient resource.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/link-type"
}
},
"mapping": [
{
"identity": "rim",
"map": "typeCode"
},
{
"identity": "cda",
"map": "n/a"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Patient",
"path": "Patient",
"short": "Information about an individual or animal receiving health care services",
"definition": "Demographics and other administrative information about an individual or animal receiving care or other health-related services.",
"alias": [
"SubjectOfCare Client Resident"
],
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "Patient[classCode=PAT]"
},
{
"identity": "cda",
"map": "ClinicalDocument.recordTarget.patientRole"
},
{
"identity": "w5",
"map": "administrative.individual"
}
]
},
{
"id": "Patient.identifier",
"path": "Patient.identifier",
"short": "An identifier for this patient",
"definition": "An identifier for this patient.",
"requirements": "Patients are almost always assigned specific numerical identifiers.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "rim",
"map": "id"
},
{
"identity": "cda",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Patient.active",
"path": "Patient.active",
"short": "Whether this patient's record is in active use",
"definition": "Whether this patient record is in active use.",
"comment": "Default is true. If a record is inactive, and linked to an active record, then future patient/record updates should occur on the other patient\n\nThis element is labeled as a modifier because when the patient record is marked as not active it is not expected to be used/referenced without being changed back to active.",
"requirements": "Need to be able to mark a patient record as not to be used because it was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "statusCode"
},
{
"identity": "cda",
"map": "n/a"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Patient.name",
"path": "Patient.name",
"short": "A name associated with the patient",
"definition": "A name associated with the individual.",
"comment": "A patient may have multiple names with different uses or applicable periods. For animals, the name is a \"HumanName\" in the sense that is assigned and used by humans and has the same patterns.",
"requirements": "Need to be able to track the patient by multiple names. Examples are your official name and a partner name.",
"min": 0,
"max": "*",
"type": [
{
"code": "HumanName"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-5, PID-9"
},
{
"identity": "rim",
"map": "name"
},
{
"identity": "cda",
"map": ".patient.name"
}
]
},
{
"id": "Patient.telecom",
"path": "Patient.telecom",
"short": "A contact detail for the individual",
"definition": "A contact detail (e.g. a telephone number or an email address) by which the individual may be contacted.",
"comment": "A Patient may have multiple ways to be contacted with different uses or applicable periods. May need to have options for contacting the person urgently and also to help with identification. The address may not go directly to the individual, but may reach another party that is able to proxy for the patient (i.e. home phone, or pet owner's phone).",
"requirements": "People have (primary) ways to contact them in some way such as phone, email.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-13, PID-14, PID-40"
},
{
"identity": "rim",
"map": "telecom"
},
{
"identity": "cda",
"map": ".telecom"
}
]
},
{
"id": "Patient.gender",
"path": "Patient.gender",
"short": "male | female | other | unknown",
"definition": "Administrative Gender - the gender that the patient is considered to have for administration and record keeping purposes.",
"comment": "The gender may not match the biological sex as determined by genetics, or the individual's preferred identification. Note that for both humans and particularly animals, there are other legitimate possibilities than M and F, though the vast majority of systems and contexts only support M and F. Systems providing decision support or enforcing business rules should ideally do this on the basis of Observations dealing with the specific gender aspect of interest (anatomical, chromosonal, social, etc.) However, because these observations are infrequently recorded, defaulting to the administrative gender is common practice. Where such defaulting occurs, rule enforcement should allow for the variation between administrative and biological, chromosonal and other gender aspects. For example, an alert about a hysterectomy on a male should be handled as a warning or overrideable error, not a \"hard\" error.",
"requirements": "Needed for identification of the individual, in combination with (at least) name and birth date. Gender of individual drives many clinical processes.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdministrativeGender"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The gender of a person used for administrative purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administrative-gender"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-8"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/administrativeGender"
},
{
"identity": "cda",
"map": ".patient.administrativeGenderCode"
}
]
},
{
"id": "Patient.birthDate",
"path": "Patient.birthDate",
"short": "The date of birth for the individual",
"definition": "The date of birth for the individual.",
"comment": "At least an estimated year should be provided as a guess if the real DOB is unknown There is a standard extension \"patient-birthTime\" available that should be used where Time is required (such as in maternaty/infant care systems).",
"requirements": "Age of the individual drives many clinical processes.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-7"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/birthTime"
},
{
"identity": "cda",
"map": ".patient.birthTime"
},
{
"identity": "loinc",
"map": "21112-8"
}
]
},
{
"id": "Patient.deceased[x]",
"path": "Patient.deceased[x]",
"short": "Indicates if the individual is deceased or not",
"definition": "Indicates if the individual is deceased or not.",
"comment": "If there's no value in the instance it means there is no statement on whether or not the individual is deceased. Most systems will interpret the absence of a value as a sign of the person being alive.\n\nThis element is labeled as a modifier because once a patient is marked as deceased, the actions that are appropriate to perform on the patient may be significantly different.",
"requirements": "The fact that a patient is deceased influences the clinical process. Also, in human communication and relation management it is necessary to know whether the person is alive.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "dateTime"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-30 (bool) and PID-29 (datetime)"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/deceasedInd, player[classCode=PSN|ANM and determinerCode=INSTANCE]/deceasedTime"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.address",
"path": "Patient.address",
"short": "Addresses for the individual",
"definition": "Addresses for the individual.",
"comment": "Patient may have multiple addresses with different uses or applicable periods.",
"requirements": "May need to keep track of patient addresses for contacting, billing or reporting requirements and also to help with identification.",
"min": 0,
"max": "*",
"type": [
{
"code": "Address"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-11"
},
{
"identity": "rim",
"map": "addr"
},
{
"identity": "cda",
"map": ".addr"
}
]
},
{
"id": "Patient.maritalStatus",
"path": "Patient.maritalStatus",
"short": "Marital (civil) status of a patient",
"definition": "This field contains a patient's most recent marital (civil) status.",
"requirements": "Most, if not all systems capture it.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "MaritalStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "The domestic partnership status of a person.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/marital-status"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-16"
},
{
"identity": "rim",
"map": "player[classCode=PSN]/maritalStatusCode"
},
{
"identity": "cda",
"map": ".patient.maritalStatusCode"
}
]
},
{
"id": "Patient.multipleBirth[x]",
"path": "Patient.multipleBirth[x]",
"short": "Whether patient is part of a multiple birth",
"definition": "Indicates whether the patient is part of a multiple (bool) or indicates the actual birth order (integer).",
"comment": "Where the valueInteger is provided, the number is the birth number in the sequence.\nE.g. The middle birth in tripplets would be valueInteger=2 and the third born would have valueInteger=3\nIf a bool value was provided for this tripplets examle, then all 3 patient records would have valueBool=true (the ordering is not indicated).",
"requirements": "For disambiguation of multiple-birth children, especially relevant where the care provider doesn't meet the patient, such as labs.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "integer"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-24 (bool), PID-25 (integer)"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/multipleBirthInd, player[classCode=PSN|ANM and determinerCode=INSTANCE]/multipleBirthOrderNumber"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.photo",
"path": "Patient.photo",
"short": "Image of the patient",
"definition": "Image of the patient.",
"requirements": "Many EHR systems have the capability to capture an image of the patient. Fits with newer social media usage too.",
"min": 0,
"max": "*",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX-5 - needs a profile"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/desc"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Contact"
}
],
"path": "Patient.contact",
"short": "A contact party (e.g. guardian, partner, friend) for the patient",
"definition": "A contact party (e.g. guardian, partner, friend) for the patient.",
"comment": "Contact covers all kinds of contact parties: family members, business contacts, guardians, caregivers. Not applicable to register pedigree and family ties beyond use of having contact.",
"requirements": "Need to track people you can contact about the patient.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "pat-1",
"severity": "error",
"human": "SHALL at least contain a contact's details or a reference to an organization",
"expression": "name.exists() or telecom.exists() or address.exists() or organization.exists()",
"xpath": "exists(f:name) or exists(f:telecom) or exists(f:address) or exists(f:organization)"
}
],
"mapping": [
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/scopedRole[classCode=CON]"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.relationship",
"path": "Patient.contact.relationship",
"short": "The kind of relationship",
"definition": "The nature of the relationship between the patient and the contact person.",
"requirements": "Used to determine which contact person is the most relevant to approach, depending on circumstances.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ContactRelationship"
}
],
"strength": "extensible",
"description": "The nature of the relationship between a patient and a contact person for that patient.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v2-0131"
}
},
"mapping": [
{
"identity": "v2",
"map": "NK1-7, NK1-3"
},
{
"identity": "rim",
"map": "code"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.name",
"path": "Patient.contact.name",
"short": "A name associated with the contact person",
"definition": "A name associated with the contact person.",
"requirements": "Contact persons need to be identified by name, but it is uncommon to need details about multiple other names for that contact person.",
"min": 0,
"max": "1",
"type": [
{
"code": "HumanName"
}
],
"mapping": [
{
"identity": "v2",
"map": "NK1-2"
},
{
"identity": "rim",
"map": "name"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.telecom",
"path": "Patient.contact.telecom",
"short": "A contact detail for the person",
"definition": "A contact detail for the person, e.g. a telephone number or an email address.",
"comment": "Contact may have multiple ways to be contacted with different uses or applicable periods. May need to have options for contacting the person urgently, and also to help with identification.",
"requirements": "People have (primary) ways to contact them in some way such as phone, email.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"mapping": [
{
"identity": "v2",
"map": "NK1-5, NK1-6, NK1-40"
},
{
"identity": "rim",
"map": "telecom"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.address",
"path": "Patient.contact.address",
"short": "Address for the contact person",
"definition": "Address for the contact person.",
"requirements": "Need to keep track where the contact person can be contacted per postal mail or visited.",
"min": 0,
"max": "1",
"type": [
{
"code": "Address"
}
],
"mapping": [
{
"identity": "v2",
"map": "NK1-4"
},
{
"identity": "rim",
"map": "addr"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.gender",
"path": "Patient.contact.gender",
"short": "male | female | other | unknown",
"definition": "Administrative Gender - the gender that the contact person is considered to have for administration and record keeping purposes.",
"requirements": "Needed to address the person correctly.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdministrativeGender"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The gender of a person used for administrative purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administrative-gender"
}
},
"mapping": [
{
"identity": "v2",
"map": "NK1-15"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/administrativeGender"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.organization",
"path": "Patient.contact.organization",
"short": "Organization that is associated with the contact",
"definition": "Organization on behalf of which the contact is acting or for which the contact is working.",
"requirements": "For guardians or business related contacts, the organization is relevant.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"condition": [
"pat-1"
],
"mapping": [
{
"identity": "v2",
"map": "NK1-13, NK1-30, NK1-31, NK1-32, NK1-41"
},
{
"identity": "rim",
"map": "scoper"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.contact.period",
"path": "Patient.contact.period",
"short": "The period during which this contact person or organization is valid to be contacted relating to this patient",
"definition": "The period during which this contact person or organization is valid to be contacted relating to this patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": "effectiveTime"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.animal",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Animal"
}
],
"path": "Patient.animal",
"short": "This patient is known to be an animal (non-human)",
"definition": "This patient is known to be an animal.",
"comment": "The animal element is labeled \"Is Modifier\" since patients may be non-human. Systems SHALL either handle patient details appropriately (e.g. inform users patient is not human) or reject declared animal records. The absense of the animal element does not imply that the patient is a human. If a system requires such a positive assertion that the patient is human, an extension will be required. (Do not use a species of homo-sapiens in animal species, as this would incorrectly infer that the patient is an animal).",
"requirements": "Many clinical systems are extended to care for animal patients as well as human.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "player[classCode=ANM]"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.animal.species",
"path": "Patient.animal.species",
"short": "E.g. Dog, Cow",
"definition": "Identifies the high level taxonomic categorization of the kind of animal.",
"comment": "If the patient is non-human, at least a species SHALL be specified. Species SHALL be a widely recognised taxonomic classification. It may or may not be Linnaean taxonomy and may or may not be at the level of species. If the level is finer than species--such as a breed code--the code system used SHALL allow inference of the species. (The common example is that the word \"Hereford\" does not allow inference of the species Bos taurus, because there is a Hereford pig breed, but the SNOMED CT code for \"Hereford Cattle Breed\" does.).",
"requirements": "Need to know what kind of animal.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AnimalSpecies"
}
],
"strength": "example",
"description": "The species of an animal.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/animal-species"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-35"
},
{
"identity": "rim",
"map": "code"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.animal.breed",
"path": "Patient.animal.breed",
"short": "E.g. Poodle, Angus",
"definition": "Identifies the detailed categorization of the kind of animal.",
"comment": "Breed MAY be used to provide further taxonomic or non-taxonomic classification. It may involve local or proprietary designation--such as commercial strain--and/or additional information such as production type.",
"requirements": "May need to know the specific kind within the species.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AnimalBreed"
}
],
"strength": "example",
"description": "The breed of an animal.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/animal-breeds"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-37"
},
{
"identity": "rim",
"map": "playedRole[classCode=GEN]/scoper[classCode=ANM, determinerCode=KIND]/code"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.animal.genderStatus",
"path": "Patient.animal.genderStatus",
"short": "E.g. Neutered, Intact",
"definition": "Indicates the current state of the animal's reproductive organs.",
"requirements": "Gender status can affect housing and animal behavior.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AnimalGenderStatus"
}
],
"strength": "example",
"description": "The state of the animal's reproductive organs.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/animal-genderstatus"
}
},
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "genderStatusCode"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.communication",
"path": "Patient.communication",
"short": "A list of Languages which may be used to communicate with the patient about his or her health",
"definition": "Languages which may be used to communicate with the patient about his or her health.",
"comment": "If no language is specified, this *implies* that the default local language is spoken. If you need to convey proficiency for multiple modes then you need multiple Patient.Communication associations. For animals, language is not a relevant field, and should be absent from the instance. If the Patient does not speak the default local language, then the Interpreter Required Standard can be used to explicitly declare that an interpreter is required.",
"requirements": "If a patient does not speak the local language, interpreters may be required, so languages spoken and proficiency is an important things to keep track of both for patient and other persons of interest.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": "LanguageCommunication"
},
{
"identity": "cda",
"map": "patient.languageCommunication"
}
]
},
{
"id": "Patient.communication.language",
"path": "Patient.communication.language",
"short": "The language which can be used to communicate with the patient about his or her health",
"definition": "The ISO-639-1 alpha 2 code in lower case for the language, optionally followed by a hyphen and the ISO-3166-1 alpha 2 code for the region in upper case; e.g. \"en\" for English, or \"en-US\" for American English versus \"en-EN\" for England English.",
"comment": "The structure aa-BB with this exact casing is one the most widely used notations for locale. However not all systems actually code this but instead have it as free text. Hence CodeableConcept instead of code as the data type.",
"requirements": "Most systems in multilingual countries will want to convey language. Not all systems actually need the regional dialect.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-15, LAN-2"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/languageCommunication/code"
},
{
"identity": "cda",
"map": ".languageCode"
}
]
},
{
"id": "Patient.communication.preferred",
"path": "Patient.communication.preferred",
"short": "Language preference indicator",
"definition": "Indicates whether or not the patient prefers this language (over other languages he masters up a certain level).",
"comment": "This language is specifically identified for communicating healthcare information.",
"requirements": "People that master multiple languages up to certain level may prefer one or more, i.e. feel more confident in communicating in a particular language making other languages sort of a fall back method.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-15"
},
{
"identity": "rim",
"map": "preferenceInd"
},
{
"identity": "cda",
"map": ".preferenceInd"
}
]
},
{
"id": "Patient.generalPractitioner",
"path": "Patient.generalPractitioner",
"short": "Patient's nominated primary care provider",
"definition": "Patient's nominated care provider.",
"comment": "This may be the primary care provider (in a GP context), or it may be a patient nominated care manager in a community/disablity setting, or even organization that will provide people to perform the care provider roles.\n\nIt is not to be used to record Care Teams, these should be in a CareTeam resource that may be linked to the CarePlan or EpisodeOfCare resources.",
"alias": [
"careProvider"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "v2",
"map": "PD1-4"
},
{
"identity": "rim",
"map": "subjectOf.CareEvent.performer.AssignedEntity"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.managingOrganization",
"path": "Patient.managingOrganization",
"short": "Organization that is the custodian of the patient record",
"definition": "Organization that is the custodian of the patient record.",
"comment": "There is only one managing organization for a specific patient record. Other organizations will have their own Patient record, and may use the Link property to join the records together (or a Person resource which can include confidence ratings for the association).",
"requirements": "Need to know who recognizes this patient record, manages and updates it.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "scoper"
},
{
"identity": "cda",
"map": ".providerOrganization"
}
]
},
{
"id": "Patient.link",
"path": "Patient.link",
"short": "Link to another patient resource that concerns the same actual person",
"definition": "Link to another patient resource that concerns the same actual patient.",
"comment": "There is no assumption that linked patient records have mutual links. \n\nThis element is labelled as a modifier because it may not be the main Patient resource, and the referenced patient should be used instead of this Patient record. This is when the link.type value is 'replaced-by'.",
"requirements": "There are multiple usecases: \n\n* Duplicate patient records due to the clerical errors associated with the difficulties of identifying humans consistently, and * Distribution of patient information across multiple servers.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "outboundLink"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.link.other",
"path": "Patient.link.other",
"short": "The other patient or related person resource that the link refers to",
"definition": "The other patient resource that the link refers to.",
"comment": "Referencing a RelatedPerson here removes the need to use a Person record to associate a Patient and RelatedPerson as the same individual.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-3, MRG-1"
},
{
"identity": "rim",
"map": "id"
},
{
"identity": "cda",
"map": "n/a"
}
]
},
{
"id": "Patient.link.type",
"path": "Patient.link.type",
"short": "replaced-by | replaces | refer | seealso - type of link",
"definition": "The type of link between this patient resource and another patient resource.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "LinkType"
}
],
"strength": "required",
"description": "The type of link between this patient resource and another patient resource.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/link-type"
}
},
"mapping": [
{
"identity": "rim",
"map": "typeCode"
},
{
"identity": "cda",
"map": "n/a"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/PaymentNotice",
"resource": {
"resourceType": "StructureDefinition",
"id": "PaymentNotice",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints PaymentNotice DomainResource PaymentNotice request
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..* Identifier Business Identifier
status ?!Σ 0..1 code active | cancelled | draft | entered-in-error
Financial Resource Status Codes (Required) request 0..1 Reference(Any) Request reference response 0..1 Reference(Any) Response reference statusDate 0..1 date Payment or clearing date created 0..1 dateTime Creation date target 0..1 Reference(Organization) Insurer or Regulatory body provider 0..1 Reference(Practitioner) Responsible practitioner organization 0..1 Reference(Organization) Responsible organization paymentStatus 0..1 CodeableConcept Whether payment has been sent or cleared
Payment Status Codes (Example)
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fm"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/PaymentNotice",
"name": "PaymentNotice",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Financial Management)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for PaymentNotice Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "cdanetv4",
"uri": "http://www.cda-adc.ca/en/services/cdanet/",
"name": "Canadian Dental Association eclaims standard"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "PaymentNotice",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "PaymentNotice",
"path": "PaymentNotice",
"short": "PaymentNotice request",
"definition": "This resource provides the status of the payment for goods and services rendered, and the request and response resource references.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "financial.payment"
}
]
},
{
"id": "PaymentNotice.id",
"path": "PaymentNotice.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "PaymentNotice.meta",
"path": "PaymentNotice.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "PaymentNotice.implicitRules",
"path": "PaymentNotice.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "PaymentNotice.language",
"path": "PaymentNotice.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "PaymentNotice.text",
"path": "PaymentNotice.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "PaymentNotice.contained",
"path": "PaymentNotice.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PaymentNotice.extension",
"path": "PaymentNotice.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PaymentNotice.modifierExtension",
"path": "PaymentNotice.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PaymentNotice.identifier",
"path": "PaymentNotice.identifier",
"short": "Business Identifier",
"definition": "The notice business identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "PaymentNotice.status",
"path": "PaymentNotice.status",
"short": "active | cancelled | draft | entered-in-error",
"definition": "The status of the resource instance.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PaymentNoticeStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the resource instance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/fm-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "PaymentNotice.request",
"path": "PaymentNotice.request",
"short": "Request reference",
"definition": "Reference of resource for which payment is being made.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.basedOn"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "PaymentNotice.response",
"path": "PaymentNotice.response",
"short": "Response reference",
"definition": "Reference of response to resource for which payment is being made.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "PaymentNotice.statusDate",
"path": "PaymentNotice.statusDate",
"short": "Payment or clearing date",
"definition": "The date when the above payment action occurrred.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "PaymentNotice.created",
"path": "PaymentNotice.created",
"short": "Creation date",
"definition": "The date when this resource was created.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "PaymentNotice.target",
"path": "PaymentNotice.target",
"short": "Insurer or Regulatory body",
"definition": "The Insurer who is target of the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PaymentNotice.provider",
"path": "PaymentNotice.provider",
"short": "Responsible practitioner",
"definition": "The practitioner who is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.actor"
},
{
"identity": "cdanetv4",
"map": "B01"
},
{
"identity": "v2",
"map": "B01"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "PaymentNotice.organization",
"path": "PaymentNotice.organization",
"short": "Responsible organization",
"definition": "The organization which is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.onBehalfOf"
},
{
"identity": "cdanetv4",
"map": "B02"
},
{
"identity": "v2",
"map": "B02"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "PaymentNotice.paymentStatus",
"path": "PaymentNotice.paymentStatus",
"short": "Whether payment has been sent or cleared",
"definition": "The payment status, typically paid: payment sent, cleared: payment received.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PaymentStatus"
}
],
"strength": "example",
"description": "The payment conveyance status codes",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/payment-status"
}
},
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
}
]
},
"differential": {
"element": [
{
"id": "PaymentNotice",
"path": "PaymentNotice",
"short": "PaymentNotice request",
"definition": "This resource provides the status of the payment for goods and services rendered, and the request and response resource references.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "financial.payment"
}
]
},
{
"id": "PaymentNotice.identifier",
"path": "PaymentNotice.identifier",
"short": "Business Identifier",
"definition": "The notice business identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "PaymentNotice.status",
"path": "PaymentNotice.status",
"short": "active | cancelled | draft | entered-in-error",
"definition": "The status of the resource instance.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PaymentNoticeStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the resource instance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/fm-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "PaymentNotice.request",
"path": "PaymentNotice.request",
"short": "Request reference",
"definition": "Reference of resource for which payment is being made.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.basedOn"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "PaymentNotice.response",
"path": "PaymentNotice.response",
"short": "Response reference",
"definition": "Reference of response to resource for which payment is being made.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "PaymentNotice.statusDate",
"path": "PaymentNotice.statusDate",
"short": "Payment or clearing date",
"definition": "The date when the above payment action occurrred.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "PaymentNotice.created",
"path": "PaymentNotice.created",
"short": "Creation date",
"definition": "The date when this resource was created.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "PaymentNotice.target",
"path": "PaymentNotice.target",
"short": "Insurer or Regulatory body",
"definition": "The Insurer who is target of the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PaymentNotice.provider",
"path": "PaymentNotice.provider",
"short": "Responsible practitioner",
"definition": "The practitioner who is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.actor"
},
{
"identity": "cdanetv4",
"map": "B01"
},
{
"identity": "v2",
"map": "B01"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "PaymentNotice.organization",
"path": "PaymentNotice.organization",
"short": "Responsible organization",
"definition": "The organization which is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.onBehalfOf"
},
{
"identity": "cdanetv4",
"map": "B02"
},
{
"identity": "v2",
"map": "B02"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "PaymentNotice.paymentStatus",
"path": "PaymentNotice.paymentStatus",
"short": "Whether payment has been sent or cleared",
"definition": "The payment status, typically paid: payment sent, cleared: payment received.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PaymentStatus"
}
],
"strength": "example",
"description": "The payment conveyance status codes",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/payment-status"
}
},
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/PaymentReconciliation",
"resource": {
"resourceType": "StructureDefinition",
"id": "PaymentReconciliation",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints PaymentReconciliation DomainResource PaymentReconciliation resource
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..* Identifier Business Identifier
status ?!Σ 0..1 code active | cancelled | draft | entered-in-error
Financial Resource Status Codes (Required) period 0..1 Period Period covered created 0..1 dateTime Creation date organization 0..1 Reference(Organization) Insurer request 0..1 Reference(ProcessRequest) Claim reference outcome 0..1 CodeableConcept complete | error | partial
RemittanceOutcome (Required) disposition 0..1 string Disposition Message requestProvider 0..1 Reference(Practitioner) Responsible practitioner requestOrganization 0..1 Reference(Organization) Responsible organization detail 0..* BackboneElement List of settlements
type 1..1 CodeableConcept Type code
Payment Type Codes (Example) request 0..1 Reference(Any) Claim response 0..1 Reference(Any) Claim Response submitter 0..1 Reference(Organization) Organization which submitted the claim payee 0..1 Reference(Organization) Organization which is receiving the payment date 0..1 date Invoice date amount 0..1 Money Amount being paid form 0..1 CodeableConcept Printed Form Identifier
Form Codes (Example) total 0..1 Money Total amount of Payment processNote 0..* BackboneElement Processing comments
type 0..1 CodeableConcept display | print | printoper
NoteType (Required) text 0..1 string Comment on the processing
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fm"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/PaymentReconciliation",
"name": "PaymentReconciliation",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Financial Management)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for PaymentReconciliation Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "cdanetv4",
"uri": "http://www.cda-adc.ca/en/services/cdanet/",
"name": "Canadian Dental Association eclaims standard"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "PaymentReconciliation",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "PaymentReconciliation",
"path": "PaymentReconciliation",
"short": "PaymentReconciliation resource",
"definition": "This resource provides payment details and claim references supporting a bulk payment.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "w5",
"map": "financial.payment"
}
]
},
{
"id": "PaymentReconciliation.id",
"path": "PaymentReconciliation.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "PaymentReconciliation.meta",
"path": "PaymentReconciliation.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "PaymentReconciliation.implicitRules",
"path": "PaymentReconciliation.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "PaymentReconciliation.language",
"path": "PaymentReconciliation.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "PaymentReconciliation.text",
"path": "PaymentReconciliation.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "PaymentReconciliation.contained",
"path": "PaymentReconciliation.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PaymentReconciliation.extension",
"path": "PaymentReconciliation.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PaymentReconciliation.modifierExtension",
"path": "PaymentReconciliation.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PaymentReconciliation.identifier",
"path": "PaymentReconciliation.identifier",
"short": "Business Identifier",
"definition": "The Response business identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "PaymentReconciliation.status",
"path": "PaymentReconciliation.status",
"short": "active | cancelled | draft | entered-in-error",
"definition": "The status of the resource instance.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PaymentReconciliationStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the resource instance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/fm-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "PaymentReconciliation.period",
"path": "PaymentReconciliation.period",
"short": "Period covered",
"definition": "The period of time for which payments have been gathered into this bulk payment for settlement.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "PaymentReconciliation.created",
"path": "PaymentReconciliation.created",
"short": "Creation date",
"definition": "The date when the enclosed suite of services were performed or completed.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence[x]"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "PaymentReconciliation.organization",
"path": "PaymentReconciliation.organization",
"short": "Insurer",
"definition": "The Insurer who produced this adjudicated response.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.onBehalfOf"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "PaymentReconciliation.request",
"path": "PaymentReconciliation.request",
"short": "Claim reference",
"definition": "Original request resource reference.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcessRequest"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "A02|G01"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "PaymentReconciliation.outcome",
"path": "PaymentReconciliation.outcome",
"short": "complete | error | partial",
"definition": "Transaction status: error, complete.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RemittanceOutcome"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The outcome of the processing.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/remittance-outcome"
}
}
},
{
"id": "PaymentReconciliation.disposition",
"path": "PaymentReconciliation.disposition",
"short": "Disposition Message",
"definition": "A description of the status of the adjudication.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.note"
}
]
},
{
"id": "PaymentReconciliation.requestProvider",
"path": "PaymentReconciliation.requestProvider",
"short": "Responsible practitioner",
"definition": "The practitioner who is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "B01"
}
]
},
{
"id": "PaymentReconciliation.requestOrganization",
"path": "PaymentReconciliation.requestOrganization",
"short": "Responsible organization",
"definition": "The organization which is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
]
},
{
"id": "PaymentReconciliation.detail",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Details"
}
],
"path": "PaymentReconciliation.detail",
"short": "List of settlements",
"definition": "List of individual settlement amounts and the corresponding transaction.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "PaymentReconciliation.detail.id",
"path": "PaymentReconciliation.detail.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PaymentReconciliation.detail.extension",
"path": "PaymentReconciliation.detail.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PaymentReconciliation.detail.modifierExtension",
"path": "PaymentReconciliation.detail.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PaymentReconciliation.detail.type",
"path": "PaymentReconciliation.detail.type",
"short": "Type code",
"definition": "Code to indicate the nature of the payment, adjustment, funds advance, etc.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PaymentType"
}
],
"strength": "example",
"description": "The reason for the amount: payment, adjustment, advance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/payment-type"
}
}
},
{
"id": "PaymentReconciliation.detail.request",
"path": "PaymentReconciliation.detail.request",
"short": "Claim",
"definition": "The claim or financial resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "PaymentReconciliation.detail.response",
"path": "PaymentReconciliation.detail.response",
"short": "Claim Response",
"definition": "The claim response resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "PaymentReconciliation.detail.submitter",
"path": "PaymentReconciliation.detail.submitter",
"short": "Organization which submitted the claim",
"definition": "The Organization which submitted the claim or financial transaction.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
]
},
{
"id": "PaymentReconciliation.detail.payee",
"path": "PaymentReconciliation.detail.payee",
"short": "Organization which is receiving the payment",
"definition": "The organization which is receiving the payment.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "PaymentReconciliation.detail.date",
"path": "PaymentReconciliation.detail.date",
"short": "Invoice date",
"definition": "The date of the invoice or financial resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
]
},
{
"id": "PaymentReconciliation.detail.amount",
"path": "PaymentReconciliation.detail.amount",
"short": "Amount being paid",
"definition": "Amount paid for this detail.",
"min": 0,
"max": "1",
"type": [
{
"code": "Money"
}
]
},
{
"id": "PaymentReconciliation.form",
"path": "PaymentReconciliation.form",
"short": "Printed Form Identifier",
"definition": "The form to be used for printing the content.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Forms"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "example",
"description": "The forms codes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/forms"
}
},
"mapping": [
{
"identity": "cdanetv4",
"map": "G42"
}
]
},
{
"id": "PaymentReconciliation.total",
"path": "PaymentReconciliation.total",
"short": "Total amount of Payment",
"definition": "Total payment amount.",
"min": 0,
"max": "1",
"type": [
{
"code": "Money"
}
]
},
{
"id": "PaymentReconciliation.processNote",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Notes"
}
],
"path": "PaymentReconciliation.processNote",
"short": "Processing comments",
"definition": "Suite of notes.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "PaymentReconciliation.processNote.id",
"path": "PaymentReconciliation.processNote.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PaymentReconciliation.processNote.extension",
"path": "PaymentReconciliation.processNote.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PaymentReconciliation.processNote.modifierExtension",
"path": "PaymentReconciliation.processNote.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PaymentReconciliation.processNote.type",
"path": "PaymentReconciliation.processNote.type",
"short": "display | print | printoper",
"definition": "The note purpose: Print/Display.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NoteType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The presentation types of notes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/note-type"
}
}
},
{
"id": "PaymentReconciliation.processNote.text",
"path": "PaymentReconciliation.processNote.text",
"short": "Comment on the processing",
"definition": "The note text.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "G32"
}
]
}
]
},
"differential": {
"element": [
{
"id": "PaymentReconciliation",
"path": "PaymentReconciliation",
"short": "PaymentReconciliation resource",
"definition": "This resource provides payment details and claim references supporting a bulk payment.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "w5",
"map": "financial.payment"
}
]
},
{
"id": "PaymentReconciliation.identifier",
"path": "PaymentReconciliation.identifier",
"short": "Business Identifier",
"definition": "The Response business identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "PaymentReconciliation.status",
"path": "PaymentReconciliation.status",
"short": "active | cancelled | draft | entered-in-error",
"definition": "The status of the resource instance.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PaymentReconciliationStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the resource instance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/fm-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "PaymentReconciliation.period",
"path": "PaymentReconciliation.period",
"short": "Period covered",
"definition": "The period of time for which payments have been gathered into this bulk payment for settlement.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "PaymentReconciliation.created",
"path": "PaymentReconciliation.created",
"short": "Creation date",
"definition": "The date when the enclosed suite of services were performed or completed.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence[x]"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "PaymentReconciliation.organization",
"path": "PaymentReconciliation.organization",
"short": "Insurer",
"definition": "The Insurer who produced this adjudicated response.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.onBehalfOf"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "PaymentReconciliation.request",
"path": "PaymentReconciliation.request",
"short": "Claim reference",
"definition": "Original request resource reference.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcessRequest"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "A02|G01"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "PaymentReconciliation.outcome",
"path": "PaymentReconciliation.outcome",
"short": "complete | error | partial",
"definition": "Transaction status: error, complete.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RemittanceOutcome"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The outcome of the processing.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/remittance-outcome"
}
}
},
{
"id": "PaymentReconciliation.disposition",
"path": "PaymentReconciliation.disposition",
"short": "Disposition Message",
"definition": "A description of the status of the adjudication.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.note"
}
]
},
{
"id": "PaymentReconciliation.requestProvider",
"path": "PaymentReconciliation.requestProvider",
"short": "Responsible practitioner",
"definition": "The practitioner who is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "B01"
}
]
},
{
"id": "PaymentReconciliation.requestOrganization",
"path": "PaymentReconciliation.requestOrganization",
"short": "Responsible organization",
"definition": "The organization which is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
]
},
{
"id": "PaymentReconciliation.detail",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Details"
}
],
"path": "PaymentReconciliation.detail",
"short": "List of settlements",
"definition": "List of individual settlement amounts and the corresponding transaction.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "PaymentReconciliation.detail.type",
"path": "PaymentReconciliation.detail.type",
"short": "Type code",
"definition": "Code to indicate the nature of the payment, adjustment, funds advance, etc.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PaymentType"
}
],
"strength": "example",
"description": "The reason for the amount: payment, adjustment, advance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/payment-type"
}
}
},
{
"id": "PaymentReconciliation.detail.request",
"path": "PaymentReconciliation.detail.request",
"short": "Claim",
"definition": "The claim or financial resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "PaymentReconciliation.detail.response",
"path": "PaymentReconciliation.detail.response",
"short": "Claim Response",
"definition": "The claim response resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "PaymentReconciliation.detail.submitter",
"path": "PaymentReconciliation.detail.submitter",
"short": "Organization which submitted the claim",
"definition": "The Organization which submitted the claim or financial transaction.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
]
},
{
"id": "PaymentReconciliation.detail.payee",
"path": "PaymentReconciliation.detail.payee",
"short": "Organization which is receiving the payment",
"definition": "The organization which is receiving the payment.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "PaymentReconciliation.detail.date",
"path": "PaymentReconciliation.detail.date",
"short": "Invoice date",
"definition": "The date of the invoice or financial resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
]
},
{
"id": "PaymentReconciliation.detail.amount",
"path": "PaymentReconciliation.detail.amount",
"short": "Amount being paid",
"definition": "Amount paid for this detail.",
"min": 0,
"max": "1",
"type": [
{
"code": "Money"
}
]
},
{
"id": "PaymentReconciliation.form",
"path": "PaymentReconciliation.form",
"short": "Printed Form Identifier",
"definition": "The form to be used for printing the content.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Forms"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "example",
"description": "The forms codes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/forms"
}
},
"mapping": [
{
"identity": "cdanetv4",
"map": "G42"
}
]
},
{
"id": "PaymentReconciliation.total",
"path": "PaymentReconciliation.total",
"short": "Total amount of Payment",
"definition": "Total payment amount.",
"min": 0,
"max": "1",
"type": [
{
"code": "Money"
}
]
},
{
"id": "PaymentReconciliation.processNote",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Notes"
}
],
"path": "PaymentReconciliation.processNote",
"short": "Processing comments",
"definition": "Suite of notes.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "PaymentReconciliation.processNote.type",
"path": "PaymentReconciliation.processNote.type",
"short": "display | print | printoper",
"definition": "The note purpose: Print/Display.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NoteType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The presentation types of notes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/note-type"
}
}
},
{
"id": "PaymentReconciliation.processNote.text",
"path": "PaymentReconciliation.processNote.text",
"short": "Comment on the processing",
"definition": "The note text.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "G32"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Person",
"resource": {
"resourceType": "StructureDefinition",
"id": "Person",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Person DomainResource A generic person record
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..* Identifier A human identifier for this person
name Σ 0..* HumanName A name associated with the person
telecom Σ 0..* ContactPoint A contact detail for the person
gender Σ 0..1 code male | female | other | unknown
AdministrativeGender (Required) birthDate Σ 0..1 date The date on which the person was born address 0..* Address One or more addresses for the person
photo 0..1 Attachment Image of the person managingOrganization Σ 0..1 Reference(Organization) The organization that is the custodian of the person record active ?!Σ 0..1 boolean This person's record is in active use link 0..* BackboneElement Link to a resource that concerns the same actual person
target 1..1 Reference(Patient | Practitioner | RelatedPerson | Person) The resource to which this actual person is associated assurance 0..1 code level1 | level2 | level3 | level4
IdentityAssuranceLevel (Required)
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "pa"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Person",
"name": "Person",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Patient Administration)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/pafm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Person Resource",
"purpose": "Need to track persons potentially across multiple roles.",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Person",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Person",
"path": "Person",
"short": "A generic person record",
"definition": "Demographics and administrative information about a person independent of a specific health-related context.",
"comment": "The Person resource does justice to person registries that keep track of persons regardless of their role. The Person resource is also a primary resource to point to for people acting in a particular role such as SubjectofCare, Practitioner, and Agent. Very few attributes are specific to any role and so Person is kept lean. Most attributes are expected to be tied to the role the Person plays rather than the Person himself. Examples of that are Guardian (SubjectofCare), ContactParty (SubjectOfCare, Practitioner), and multipleBirthInd (SubjectofCare).",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "Person(classCode=\"PSN\" and determinerCode=\"INST\" and quantity=\"1\")"
},
{
"identity": "w5",
"map": "administrative.entity"
}
]
},
{
"id": "Person.id",
"path": "Person.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Person.meta",
"path": "Person.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Person.implicitRules",
"path": "Person.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Person.language",
"path": "Person.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Person.text",
"path": "Person.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Person.contained",
"path": "Person.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Person.extension",
"path": "Person.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Person.modifierExtension",
"path": "Person.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Person.identifier",
"path": "Person.identifier",
"short": "A human identifier for this person",
"definition": "Identifier for a person within a particular scope.",
"requirements": "People are known by a variety of ids. Some institutions maintain several, and most collect identifiers for exchange with other organizations concerning the person. Examples are national person identifier and local identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "rim",
"map": ".plays:Role(classCode='IDENT').id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Person.name",
"path": "Person.name",
"short": "A name associated with the person",
"definition": "A name associated with the person.",
"comment": "Person may have multiple names with different uses or applicable periods.",
"requirements": "Need to be able to track the person by multiple names. Examples are your official name and a partner name.",
"min": 0,
"max": "*",
"type": [
{
"code": "HumanName"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-5, PID-9"
},
{
"identity": "rim",
"map": "./name"
}
]
},
{
"id": "Person.telecom",
"path": "Person.telecom",
"short": "A contact detail for the person",
"definition": "A contact detail for the person, e.g. a telephone number or an email address.",
"comment": "Person may have multiple ways to be contacted with different uses or applicable periods. May need to have options for contacting the person urgently, and also to help with identification.",
"requirements": "People have (primary) ways to contact them in some way such as phone, email.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-13, PID-14"
},
{
"identity": "rim",
"map": "./telecom"
}
]
},
{
"id": "Person.gender",
"path": "Person.gender",
"short": "male | female | other | unknown",
"definition": "Administrative Gender.",
"comment": "The gender may not match the biological sex as determined by genetics, or the individual's preferred identification. Note that for both humans and particularly animals, there are other legitimate possibilities than M and F, though the vast majority of systems and contexts only support M and F.",
"requirements": "Needed for identification of the person, in combination with (at least) name and birth date. Gender of person drives many clinical processes.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdministrativeGender"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The gender of a person used for administrative purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administrative-gender"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-8"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/administrativeGender"
}
]
},
{
"id": "Person.birthDate",
"path": "Person.birthDate",
"short": "The date on which the person was born",
"definition": "The birth date for the person.",
"comment": "At least an estimated year should be provided as a guess if the real DOB is unknown.",
"requirements": "Age of person drives many clinical processes, and is often used in performing identification of the person. Times are not included so as to not confuse things with potential timezone issues.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-7"
},
{
"identity": "rim",
"map": "./birthTime"
}
]
},
{
"id": "Person.address",
"path": "Person.address",
"short": "One or more addresses for the person",
"definition": "One or more addresses for the person.",
"comment": "Person may have multiple addresses with different uses or applicable periods.",
"requirements": "May need to keep track of person's addresses for contacting, billing or reporting requirements and also to help with identification.",
"min": 0,
"max": "*",
"type": [
{
"code": "Address"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-11"
},
{
"identity": "rim",
"map": "./addr"
}
]
},
{
"id": "Person.photo",
"path": "Person.photo",
"short": "Image of the person",
"definition": "An image that can be displayed as a thumbnail of the person to enhance the identification of the individual.",
"min": 0,
"max": "1",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX-5 - needs a profile"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/desc"
}
]
},
{
"id": "Person.managingOrganization",
"path": "Person.managingOrganization",
"short": "The organization that is the custodian of the person record",
"definition": "The organization that is the custodian of the person record.",
"requirements": "Need to know who recognizes this person record, manages and updates it.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "scoper"
}
]
},
{
"id": "Person.active",
"path": "Person.active",
"short": "This person's record is in active use",
"definition": "Whether this person's record is in active use.",
"requirements": "Need to be able to mark a person record as not to be used because it was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Person.link",
"path": "Person.link",
"short": "Link to a resource that concerns the same actual person",
"definition": "Link to a resource that concerns the same actual person.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": "outboundLink"
}
]
},
{
"id": "Person.link.id",
"path": "Person.link.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Person.link.extension",
"path": "Person.link.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Person.link.modifierExtension",
"path": "Person.link.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Person.link.target",
"path": "Person.link.target",
"short": "The resource to which this actual person is associated",
"definition": "The resource to which this actual person is associated.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Person"
}
],
"mapping": [
{
"identity": "rim",
"map": "id"
}
]
},
{
"id": "Person.link.assurance",
"path": "Person.link.assurance",
"short": "level1 | level2 | level3 | level4",
"definition": "Level of assurance that this link is actually associated with the target resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "IdentityAssuranceLevel"
}
],
"strength": "required",
"description": "The level of confidence that this link represents the same actual person, based on NIST Authentication Levels.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/identity-assuranceLevel"
}
},
"mapping": [
{
"identity": "rim",
"map": "priorityNumber?"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Person",
"path": "Person",
"short": "A generic person record",
"definition": "Demographics and administrative information about a person independent of a specific health-related context.",
"comment": "The Person resource does justice to person registries that keep track of persons regardless of their role. The Person resource is also a primary resource to point to for people acting in a particular role such as SubjectofCare, Practitioner, and Agent. Very few attributes are specific to any role and so Person is kept lean. Most attributes are expected to be tied to the role the Person plays rather than the Person himself. Examples of that are Guardian (SubjectofCare), ContactParty (SubjectOfCare, Practitioner), and multipleBirthInd (SubjectofCare).",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "Person(classCode=\"PSN\" and determinerCode=\"INST\" and quantity=\"1\")"
},
{
"identity": "w5",
"map": "administrative.entity"
}
]
},
{
"id": "Person.identifier",
"path": "Person.identifier",
"short": "A human identifier for this person",
"definition": "Identifier for a person within a particular scope.",
"requirements": "People are known by a variety of ids. Some institutions maintain several, and most collect identifiers for exchange with other organizations concerning the person. Examples are national person identifier and local identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "rim",
"map": ".plays:Role(classCode='IDENT').id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Person.name",
"path": "Person.name",
"short": "A name associated with the person",
"definition": "A name associated with the person.",
"comment": "Person may have multiple names with different uses or applicable periods.",
"requirements": "Need to be able to track the person by multiple names. Examples are your official name and a partner name.",
"min": 0,
"max": "*",
"type": [
{
"code": "HumanName"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-5, PID-9"
},
{
"identity": "rim",
"map": "./name"
}
]
},
{
"id": "Person.telecom",
"path": "Person.telecom",
"short": "A contact detail for the person",
"definition": "A contact detail for the person, e.g. a telephone number or an email address.",
"comment": "Person may have multiple ways to be contacted with different uses or applicable periods. May need to have options for contacting the person urgently, and also to help with identification.",
"requirements": "People have (primary) ways to contact them in some way such as phone, email.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-13, PID-14"
},
{
"identity": "rim",
"map": "./telecom"
}
]
},
{
"id": "Person.gender",
"path": "Person.gender",
"short": "male | female | other | unknown",
"definition": "Administrative Gender.",
"comment": "The gender may not match the biological sex as determined by genetics, or the individual's preferred identification. Note that for both humans and particularly animals, there are other legitimate possibilities than M and F, though the vast majority of systems and contexts only support M and F.",
"requirements": "Needed for identification of the person, in combination with (at least) name and birth date. Gender of person drives many clinical processes.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdministrativeGender"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The gender of a person used for administrative purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administrative-gender"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-8"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/administrativeGender"
}
]
},
{
"id": "Person.birthDate",
"path": "Person.birthDate",
"short": "The date on which the person was born",
"definition": "The birth date for the person.",
"comment": "At least an estimated year should be provided as a guess if the real DOB is unknown.",
"requirements": "Age of person drives many clinical processes, and is often used in performing identification of the person. Times are not included so as to not confuse things with potential timezone issues.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-7"
},
{
"identity": "rim",
"map": "./birthTime"
}
]
},
{
"id": "Person.address",
"path": "Person.address",
"short": "One or more addresses for the person",
"definition": "One or more addresses for the person.",
"comment": "Person may have multiple addresses with different uses or applicable periods.",
"requirements": "May need to keep track of person's addresses for contacting, billing or reporting requirements and also to help with identification.",
"min": 0,
"max": "*",
"type": [
{
"code": "Address"
}
],
"mapping": [
{
"identity": "v2",
"map": "PID-11"
},
{
"identity": "rim",
"map": "./addr"
}
]
},
{
"id": "Person.photo",
"path": "Person.photo",
"short": "Image of the person",
"definition": "An image that can be displayed as a thumbnail of the person to enhance the identification of the individual.",
"min": 0,
"max": "1",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX-5 - needs a profile"
},
{
"identity": "rim",
"map": "player[classCode=PSN|ANM and determinerCode=INSTANCE]/desc"
}
]
},
{
"id": "Person.managingOrganization",
"path": "Person.managingOrganization",
"short": "The organization that is the custodian of the person record",
"definition": "The organization that is the custodian of the person record.",
"requirements": "Need to know who recognizes this person record, manages and updates it.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "scoper"
}
]
},
{
"id": "Person.active",
"path": "Person.active",
"short": "This person's record is in active use",
"definition": "Whether this person's record is in active use.",
"requirements": "Need to be able to mark a person record as not to be used because it was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Person.link",
"path": "Person.link",
"short": "Link to a resource that concerns the same actual person",
"definition": "Link to a resource that concerns the same actual person.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": "outboundLink"
}
]
},
{
"id": "Person.link.target",
"path": "Person.link.target",
"short": "The resource to which this actual person is associated",
"definition": "The resource to which this actual person is associated.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Person"
}
],
"mapping": [
{
"identity": "rim",
"map": "id"
}
]
},
{
"id": "Person.link.assurance",
"path": "Person.link.assurance",
"short": "level1 | level2 | level3 | level4",
"definition": "Level of assurance that this link is actually associated with the target resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "IdentityAssuranceLevel"
}
],
"strength": "required",
"description": "The level of confidence that this link represents the same actual person, based on NIST Authentication Levels.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/identity-assuranceLevel"
}
},
"mapping": [
{
"identity": "rim",
"map": "priorityNumber?"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/PlanDefinition",
"resource": {
"resourceType": "StructureDefinition",
"id": "PlanDefinition",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints PlanDefinition DomainResource The definition of a plan for a series of actions, independent of any specific patient or context
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension url Σ 0..1 uri Logical URI to reference this plan definition (globally unique) identifier Σ 0..* Identifier Additional identifier for the plan definition
version Σ 0..1 string Business version of the plan definition name Σ 0..1 string Name for this plan definition (computer friendly) title Σ 0..1 string Name for this plan definition (human friendly) type Σ 0..1 CodeableConcept order-set | protocol | eca-rule
PlanDefinitionType (Extensible) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) experimental ?!Σ 0..1 boolean For testing purposes, not real usage date Σ 0..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) description Σ 0..1 markdown Natural language description of the plan definition purpose 0..1 markdown Why this plan definition is defined usage 0..1 string Describes the clinical usage of the asset approvalDate 0..1 date When the plan definition was approved by publisher lastReviewDate 0..1 date When the plan definition was last reviewed effectivePeriod Σ 0..1 Period When the plan definition is expected to be used useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for plan definition (if applicable)
Jurisdiction ValueSet (Extensible)
topic 0..* CodeableConcept E.g. Education, Treatment, Assessment, etc
DefinitionTopic (Example)
contributor 0..* Contributor A content contributor
contact Σ 0..* ContactDetail Contact details for the publisher
copyright 0..1 markdown Use and/or publishing restrictions relatedArtifact 0..* RelatedArtifact Related artifacts for the asset
library 0..* Reference(Library) Logic used by the plan definition
goal 0..* BackboneElement What the plan is trying to accomplish
category 0..1 CodeableConcept E.g. Treatment, dietary, behavioral, etc
GoalCategory (Example) description 1..1 CodeableConcept Code or text describing the goal
SNOMED CT Clinical Findings (Example) priority 0..1 CodeableConcept high-priority | medium-priority | low-priority
GoalPriority (Preferred) start 0..1 CodeableConcept When goal pursuit begins
GoalStartEvent (Example) addresses 0..* CodeableConcept What does the goal address
Condition/Problem/Diagnosis Codes (Example)
documentation 0..* RelatedArtifact Supporting documentation for the goal
target 0..* BackboneElement Target outcome for the goal
measure 0..1 CodeableConcept The parameter whose value is to be tracked
LOINC Codes (Example) detail[x] 0..1 The target value to be achieved detailQuantity Quantity detailRange Range detailCodeableConcept CodeableConcept due 0..1 Duration Reach goal within action 0..* BackboneElement Action defined by the plan
label 0..1 string User-visible label for the action (e.g. 1. or A.) title 0..1 string User-visible title description 0..1 string Short description of the action textEquivalent 0..1 string Static text equivalent of the action, used if the dynamic aspects cannot be interpreted by the receiving system code 0..* CodeableConcept Code representing the meaning of the action or sub-actions
reason 0..* CodeableConcept Why the action should be performed
documentation 0..* RelatedArtifact Supporting documentation for the intended performer of the action
goalId 0..* id What goals this action supports
triggerDefinition 0..* TriggerDefinition When the action should be triggered
condition 0..* BackboneElement Whether or not the action is applicable
kind 1..1 code applicability | start | stop
ActionConditionKind (Required) description 0..1 string Natural language description of the condition language 0..1 string Language of the expression expression 0..1 string Boolean-valued expression input 0..* DataRequirement Input data requirements
output 0..* DataRequirement Output data definition
relatedAction 0..* BackboneElement Relationship to another action
actionId 1..1 id What action is this related to relationship 1..1 code before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end
ActionRelationshipType (Required) offset[x] 0..1 Time offset for the relationship offsetDuration Duration offsetRange Range timing[x] 0..1 When the action should take place timingDateTime dateTime timingPeriod Period timingDuration Duration timingRange Range timingTiming Timing participant 0..* BackboneElement Who should participate in the action
type 1..1 code patient | practitioner | related-person
ActionParticipantType (Required) role 0..1 CodeableConcept E.g. Nurse, Surgeon, Parent, etc
ActionParticipantRole (Example) type 0..1 Coding create | update | remove | fire-event
ActionType (Required) groupingBehavior 0..1 code visual-group | logical-group | sentence-group
ActionGroupingBehavior (Required) selectionBehavior 0..1 code any | all | all-or-none | exactly-one | at-most-one | one-or-more
ActionSelectionBehavior (Required) requiredBehavior 0..1 code must | could | must-unless-documented
ActionRequiredBehavior (Required) precheckBehavior 0..1 code yes | no
ActionPrecheckBehavior (Required) cardinalityBehavior 0..1 code single | multiple
ActionCardinalityBehavior (Required) definition 0..1 Reference(ActivityDefinition | PlanDefinition) Description of the activity to be performed transform 0..1 Reference(StructureMap) Transform to apply the template dynamicValue 0..* BackboneElement Dynamic aspects of the definition
description 0..1 string Natural language description of the dynamic value path 0..1 string The path to the element to be set dynamically language 0..1 string Language of the expression expression 0..1 string An expression that provides the dynamic value for the customization action 0..* see action A sub-action
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "cds"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/PlanDefinition",
"name": "PlanDefinition",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Clinical Decision Support)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/dss/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for PlanDefinition Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "objimpl",
"uri": "http://hl7.org/fhir/object-implementation",
"name": "Object Implementation Information"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "PlanDefinition",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"_baseDefinition": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-codegen-super",
"valueString": "MetadataResource"
}
]
},
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "PlanDefinition",
"path": "PlanDefinition",
"short": "The definition of a plan for a series of actions, independent of any specific patient or context",
"definition": "This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Definition"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "PlanDefinition.id",
"path": "PlanDefinition.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "PlanDefinition.meta",
"path": "PlanDefinition.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "PlanDefinition.implicitRules",
"path": "PlanDefinition.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "PlanDefinition.language",
"path": "PlanDefinition.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "PlanDefinition.text",
"path": "PlanDefinition.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "PlanDefinition.contained",
"path": "PlanDefinition.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PlanDefinition.extension",
"path": "PlanDefinition.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PlanDefinition.modifierExtension",
"path": "PlanDefinition.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PlanDefinition.url",
"path": "PlanDefinition.url",
"short": "Logical URI to reference this plan definition (globally unique)",
"definition": "An absolute URI that is used to identify this plan definition when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this plan definition is (or will be) published. The URL SHOULD include the major version of the plan definition. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the plan definition to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.url"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "PlanDefinition.identifier",
"path": "PlanDefinition.identifier",
"short": "Additional identifier for the plan definition",
"definition": "A formal identifier that is used to identify this plan definition when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this plan definition outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.identifier"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "PlanDefinition.version",
"path": "PlanDefinition.version",
"short": "Business version of the plan definition",
"definition": "The identifier that is used to identify this version of the plan definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the plan definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge assets, refer to the Decision Support Service specification. Note that a version is required for non-experimental active artifacts.",
"comment": "There may be different plan definition instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the plan definition with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.version"
},
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "PlanDefinition.name",
"path": "PlanDefinition.name",
"short": "Name for this plan definition (computer friendly)",
"definition": "A natural language name identifying the plan definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "PlanDefinition.title",
"path": "PlanDefinition.title",
"short": "Name for this plan definition (human friendly)",
"definition": "A short, descriptive, user-friendly title for the plan definition.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.title"
}
]
},
{
"id": "PlanDefinition.type",
"path": "PlanDefinition.type",
"short": "order-set | protocol | eca-rule",
"definition": "The type of asset the plan definition represents, e.g. an order set, protocol, or event-condition-action rule.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PlanDefinitionType"
}
],
"strength": "extensible",
"description": "The type of PlanDefinition",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/plan-definition-type"
}
}
},
{
"id": "PlanDefinition.status",
"path": "PlanDefinition.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this plan definition. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of plan definitions that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired plan definition without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.status (different ValueSet)"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "PlanDefinition.experimental",
"path": "PlanDefinition.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this plan definition is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of plan definition that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental plan definition in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level plan definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.experimental"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "PlanDefinition.date",
"path": "PlanDefinition.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the plan definition was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the plan definition changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the plan definition. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.date"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "PlanDefinition.publisher",
"path": "PlanDefinition.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the plan definition.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the plan definition is the organization or individual primarily responsible for the maintenance and upkeep of the plan definition. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the plan definition. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the plan definition. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.publisher (as string instead of Reference)"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "PlanDefinition.description",
"path": "PlanDefinition.description",
"short": "Natural language description of the plan definition",
"definition": "A free text natural language description of the plan definition from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the plan definition was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the plan definition as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.description"
}
]
},
{
"id": "PlanDefinition.purpose",
"path": "PlanDefinition.purpose",
"short": "Why this plan definition is defined",
"definition": "Explaination of why this plan definition is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the plan definition Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this plan definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.purpose"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "PlanDefinition.usage",
"path": "PlanDefinition.usage",
"short": "Describes the clinical usage of the asset",
"definition": "A detailed description of how the asset is used from a clinical perspective.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.approvalDate",
"path": "PlanDefinition.approvalDate",
"short": "When the plan definition was approved by publisher",
"definition": "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.",
"comment": "The 'date' element may be more recent than the approval date because of minor changes / editorial corrections.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.approvalDate"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "PlanDefinition.lastReviewDate",
"path": "PlanDefinition.lastReviewDate",
"short": "When the plan definition was last reviewed",
"definition": "The date on which the resource content was last reviewed. Review happens periodically after approval, but doesn't change the original approval date.",
"comment": "If specified, this is usually after the approval date.",
"requirements": "Gives a sense of how \"current\" the content is. Resources that have not been reviewed in a long time may have a risk of being less appropriate/relevant.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.lastReviewDate"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "PlanDefinition.effectivePeriod",
"path": "PlanDefinition.effectivePeriod",
"short": "When the plan definition is expected to be used",
"definition": "The period during which the plan definition content was or is planned to be in active use.",
"comment": "The effective period for a plan definition determines when the content is applicable for usage and is independent of publication and review dates. For example, a measure intended to be used for the year 2016 might be published in 2015.",
"requirements": "Allows establishing a transition before a resource comes into effect and also allows for a sunsetting process when new versions of a the plan definition are or are expected to be used instead.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.effectivePeriod"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "PlanDefinition.useContext",
"path": "PlanDefinition.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate plan definition instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.useContext"
}
]
},
{
"id": "PlanDefinition.jurisdiction",
"path": "PlanDefinition.jurisdiction",
"short": "Intended jurisdiction for plan definition (if applicable)",
"definition": "A legal or geographic region in which the plan definition is intended to be used.",
"comment": "It may be possible for the plan definition to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.jurisdiction"
}
]
},
{
"id": "PlanDefinition.topic",
"path": "PlanDefinition.topic",
"short": "E.g. Education, Treatment, Assessment, etc",
"definition": "Descriptive topics related to the content of the plan definition. Topics provide a high-level categorization of the definition that can be useful for filtering and searching.",
"requirements": "Repositories must be able to determine how to categorize the asset so that it can be found by topical searches.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "DefinitionTopic"
}
],
"strength": "example",
"description": "High-level categorization of the definition, used for searching, sorting, and filtering",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/definition-topic"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.subjectCodableConcept"
}
]
},
{
"id": "PlanDefinition.contributor",
"path": "PlanDefinition.contributor",
"short": "A content contributor",
"definition": "A contributor to the content of the asset, including authors, editors, reviewers, and endorsers.",
"requirements": "Consumers of the content must be able to quickly determine who contributed to the content of the asset.",
"min": 0,
"max": "*",
"type": [
{
"code": "Contributor"
}
]
},
{
"id": "PlanDefinition.contact",
"path": "PlanDefinition.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.contact"
}
]
},
{
"id": "PlanDefinition.copyright",
"path": "PlanDefinition.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the plan definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the plan definition.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the plan definition and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.copyright"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "PlanDefinition.relatedArtifact",
"path": "PlanDefinition.relatedArtifact",
"short": "Related artifacts for the asset",
"definition": "Related artifacts such as additional documentation, justification, or bibliographic references.",
"comment": "Each related artifact is either an attachment, or a reference to another resource, but not both.",
"requirements": "Assets must be able to provide enough information for consumers of the content (and/or interventions or results produced by the content) to be able to determine and understand the justification for and evidence in support of the content.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
]
},
{
"id": "PlanDefinition.library",
"path": "PlanDefinition.library",
"short": "Logic used by the plan definition",
"definition": "A reference to a Library resource containing any formal logic used by the plan definition.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Library"
}
]
},
{
"id": "PlanDefinition.goal",
"path": "PlanDefinition.goal",
"short": "What the plan is trying to accomplish",
"definition": "Goals that describe what the activities within the plan are intended to achieve. For example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc.",
"requirements": "Goal information needs to be captured for order sets, protocols, and care plan definitions to better describe the objectives of the protocol activities and to guide the creation of specific goals within the derived care plans and orders.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "PlanDefinition.goal.id",
"path": "PlanDefinition.goal.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.goal.extension",
"path": "PlanDefinition.goal.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.goal.modifierExtension",
"path": "PlanDefinition.goal.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PlanDefinition.goal.category",
"path": "PlanDefinition.goal.category",
"short": "E.g. Treatment, dietary, behavioral, etc",
"definition": "Indicates a category the goal falls within.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalCategory"
}
],
"strength": "example",
"description": "Example codes for grouping goals for filtering or presentation",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/goal-category"
}
}
},
{
"id": "PlanDefinition.goal.description",
"path": "PlanDefinition.goal.description",
"short": "Code or text describing the goal",
"definition": "Human-readable and/or coded description of a specific desired objective of care, such as \"control blood pressure\" or \"negotiate an obstacle course\" or \"dance with child at wedding\".",
"comment": "If no code is available, use CodeableConcept.text.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalDescription"
}
],
"strength": "example",
"description": "Describes goals that can be achieved",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/clinical-findings"
}
}
},
{
"id": "PlanDefinition.goal.priority",
"path": "PlanDefinition.goal.priority",
"short": "high-priority | medium-priority | low-priority",
"definition": "Identifies the expected level of importance associated with reaching/sustaining the defined goal.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalPriority"
}
],
"strength": "preferred",
"description": "Indicates the level of importance associated with reaching or sustaining a goal",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/goal-priority"
}
}
},
{
"id": "PlanDefinition.goal.start",
"path": "PlanDefinition.goal.start",
"short": "When goal pursuit begins",
"definition": "The event after which the goal should begin being pursued.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalStartEvent"
}
],
"strength": "example",
"description": "Identifies the types of events that might trigger the start of a goal",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/goal-start-event"
}
}
},
{
"id": "PlanDefinition.goal.addresses",
"path": "PlanDefinition.goal.addresses",
"short": "What does the goal address",
"definition": "Identifies problems, conditions, issues, or concerns the goal is intended to address.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalAddresses"
}
],
"strength": "example",
"description": "Identifies problems, conditions, issues, or concerns that goals may address",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/condition-code"
}
}
},
{
"id": "PlanDefinition.goal.documentation",
"path": "PlanDefinition.goal.documentation",
"short": "Supporting documentation for the goal",
"definition": "Didactic or other informational resources associated with the goal that provide further supporting information about the goal. Information resources can include inline text commentary and links to web resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
]
},
{
"id": "PlanDefinition.goal.target",
"path": "PlanDefinition.goal.target",
"short": "Target outcome for the goal",
"definition": "Indicates what should be done and within what timeframe.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "PlanDefinition.goal.target.id",
"path": "PlanDefinition.goal.target.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.goal.target.extension",
"path": "PlanDefinition.goal.target.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.goal.target.modifierExtension",
"path": "PlanDefinition.goal.target.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PlanDefinition.goal.target.measure",
"path": "PlanDefinition.goal.target.measure",
"short": "The parameter whose value is to be tracked",
"definition": "The parameter whose value is to be tracked, e.g. body weigth, blood pressure, or hemoglobin A1c level.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalTargetMeasure"
}
],
"strength": "example",
"description": "Identifies types of parameters that can be tracked to determine goal achievement",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-codes"
}
}
},
{
"id": "PlanDefinition.goal.target.detail[x]",
"path": "PlanDefinition.goal.target.detail[x]",
"short": "The target value to be achieved",
"definition": "The target value of the measure to be achieved to signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the high or low or both values of the range can be specified. Whan a low value is missing, it indicates that the goal is achieved at any value at or below the high value. Similarly, if the high value is missing, it indicates that the goal is achieved at any value at or above the low value.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity"
},
{
"code": "Range"
},
{
"code": "CodeableConcept"
}
]
},
{
"id": "PlanDefinition.goal.target.due",
"path": "PlanDefinition.goal.target.due",
"short": "Reach goal within",
"definition": "Indicates the timeframe after the start of the goal in which the goal should be met.",
"min": 0,
"max": "1",
"type": [
{
"code": "Duration"
}
]
},
{
"id": "PlanDefinition.action",
"path": "PlanDefinition.action",
"short": "Action defined by the plan",
"definition": "An action to be taken as part of the plan.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Is a contained Definition"
}
]
},
{
"id": "PlanDefinition.action.id",
"path": "PlanDefinition.action.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.action.extension",
"path": "PlanDefinition.action.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.action.modifierExtension",
"path": "PlanDefinition.action.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PlanDefinition.action.label",
"path": "PlanDefinition.action.label",
"short": "User-visible label for the action (e.g. 1. or A.)",
"definition": "A user-visible label for the action.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.title",
"path": "PlanDefinition.action.title",
"short": "User-visible title",
"definition": "The title of the action displayed to a user.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.title"
}
]
},
{
"id": "PlanDefinition.action.description",
"path": "PlanDefinition.action.description",
"short": "Short description of the action",
"definition": "A short description of the action used to provide a summary to display to the user.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.description"
}
]
},
{
"id": "PlanDefinition.action.textEquivalent",
"path": "PlanDefinition.action.textEquivalent",
"short": "Static text equivalent of the action, used if the dynamic aspects cannot be interpreted by the receiving system",
"definition": "A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.description"
}
]
},
{
"id": "PlanDefinition.action.code",
"path": "PlanDefinition.action.code",
"short": "Code representing the meaning of the action or sub-actions",
"definition": "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
]
},
{
"id": "PlanDefinition.action.reason",
"path": "PlanDefinition.action.reason",
"short": "Why the action should be performed",
"definition": "A description of why this action is necessary or appropriate.",
"comment": "This is different than the clinical evidence documentation, it's an actual business description of the reason for performing the action.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
]
},
{
"id": "PlanDefinition.action.documentation",
"path": "PlanDefinition.action.documentation",
"short": "Supporting documentation for the intended performer of the action",
"definition": "Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
]
},
{
"id": "PlanDefinition.action.goalId",
"path": "PlanDefinition.action.goalId",
"short": "What goals this action supports",
"definition": "Identifies goals that this action supports. The reference must be to a goal element defined within this plan definition.",
"min": 0,
"max": "*",
"type": [
{
"code": "id"
}
]
},
{
"id": "PlanDefinition.action.triggerDefinition",
"path": "PlanDefinition.action.triggerDefinition",
"short": "When the action should be triggered",
"definition": "A description of when the action should be triggered.",
"min": 0,
"max": "*",
"type": [
{
"code": "TriggerDefinition"
}
]
},
{
"id": "PlanDefinition.action.condition",
"path": "PlanDefinition.action.condition",
"short": "Whether or not the action is applicable",
"definition": "An expression that describes applicability criteria, or start/stop conditions for the action.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "PlanDefinition.action.condition.id",
"path": "PlanDefinition.action.condition.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.action.condition.extension",
"path": "PlanDefinition.action.condition.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.action.condition.modifierExtension",
"path": "PlanDefinition.action.condition.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PlanDefinition.action.condition.kind",
"path": "PlanDefinition.action.condition.kind",
"short": "applicability | start | stop",
"definition": "The kind of condition.",
"comment": "Applicability criteria are used to determine immediate applicability when a plan definition is applied to a given context. Start and stop criteria are carried through application and used to describe when enter/exit criteria for an action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionConditionKind"
}
],
"strength": "required",
"description": "Defines the kinds of conditions that can appear on actions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-condition-kind"
}
}
},
{
"id": "PlanDefinition.action.condition.description",
"path": "PlanDefinition.action.condition.description",
"short": "Natural language description of the condition",
"definition": "A brief, natural language description of the condition that effectively communicates the intended semantics.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.condition.language",
"path": "PlanDefinition.action.condition.language",
"short": "Language of the expression",
"definition": "The media type of the language for the expression.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.condition.expression",
"path": "PlanDefinition.action.condition.expression",
"short": "Boolean-valued expression",
"definition": "An expression that returns true or false, indicating whether or not the condition is satisfied.",
"comment": "The expression may be inlined, or may be a reference to a named expression within a logic library referenced by the library element.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.input",
"path": "PlanDefinition.action.input",
"short": "Input data requirements",
"definition": "Defines input data requirements for the action.",
"min": 0,
"max": "*",
"type": [
{
"code": "DataRequirement"
}
]
},
{
"id": "PlanDefinition.action.output",
"path": "PlanDefinition.action.output",
"short": "Output data definition",
"definition": "Defines the outputs of the action, if any.",
"min": 0,
"max": "*",
"type": [
{
"code": "DataRequirement"
}
]
},
{
"id": "PlanDefinition.action.relatedAction",
"path": "PlanDefinition.action.relatedAction",
"short": "Relationship to another action",
"definition": "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".",
"comment": "When an action depends on multiple actions, the meaning is that all actions are dependencies, rather than that any of the actions are a dependency.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "PlanDefinition.action.relatedAction.id",
"path": "PlanDefinition.action.relatedAction.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.action.relatedAction.extension",
"path": "PlanDefinition.action.relatedAction.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.action.relatedAction.modifierExtension",
"path": "PlanDefinition.action.relatedAction.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PlanDefinition.action.relatedAction.actionId",
"path": "PlanDefinition.action.relatedAction.actionId",
"short": "What action is this related to",
"definition": "The element id of the related action.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "PlanDefinition.action.relatedAction.relationship",
"path": "PlanDefinition.action.relatedAction.relationship",
"short": "before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end",
"definition": "The relationship of this action to the related action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionRelationshipType"
}
],
"strength": "required",
"description": "Defines the types of relationships between actions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-relationship-type"
}
}
},
{
"id": "PlanDefinition.action.relatedAction.offset[x]",
"path": "PlanDefinition.action.relatedAction.offset[x]",
"short": "Time offset for the relationship",
"definition": "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.",
"min": 0,
"max": "1",
"type": [
{
"code": "Duration"
},
{
"code": "Range"
}
]
},
{
"id": "PlanDefinition.action.timing[x]",
"path": "PlanDefinition.action.timing[x]",
"short": "When the action should take place",
"definition": "An optional value describing when the action should be performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
},
{
"code": "Duration"
},
{
"code": "Range"
},
{
"code": "Timing"
}
]
},
{
"id": "PlanDefinition.action.participant",
"path": "PlanDefinition.action.participant",
"short": "Who should participate in the action",
"definition": "Indicates who should participate in performing the action described.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "PlanDefinition.action.participant.id",
"path": "PlanDefinition.action.participant.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.action.participant.extension",
"path": "PlanDefinition.action.participant.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.action.participant.modifierExtension",
"path": "PlanDefinition.action.participant.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PlanDefinition.action.participant.type",
"path": "PlanDefinition.action.participant.type",
"short": "patient | practitioner | related-person",
"definition": "The type of participant in the action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionParticipantType"
}
],
"strength": "required",
"description": "The type of participant for the action",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-participant-type"
}
}
},
{
"id": "PlanDefinition.action.participant.role",
"path": "PlanDefinition.action.participant.role",
"short": "E.g. Nurse, Surgeon, Parent, etc",
"definition": "The role the participant should play in performing the described action.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionParticipantRole"
}
],
"strength": "example",
"description": "Defines roles played by participants for the action",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-participant-role"
}
}
},
{
"id": "PlanDefinition.action.type",
"path": "PlanDefinition.action.type",
"short": "create | update | remove | fire-event",
"definition": "The type of action to perform (create, update, remove).",
"min": 0,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionType"
}
],
"strength": "required",
"description": "The type of action to be performed",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-type"
}
}
},
{
"id": "PlanDefinition.action.groupingBehavior",
"path": "PlanDefinition.action.groupingBehavior",
"short": "visual-group | logical-group | sentence-group",
"definition": "Defines the grouping behavior for the action and its children.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionGroupingBehavior"
}
],
"strength": "required",
"description": "Defines organization behavior of a group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-grouping-behavior"
}
}
},
{
"id": "PlanDefinition.action.selectionBehavior",
"path": "PlanDefinition.action.selectionBehavior",
"short": "any | all | all-or-none | exactly-one | at-most-one | one-or-more",
"definition": "Defines the selection behavior for the action and its children.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionSelectionBehavior"
}
],
"strength": "required",
"description": "Defines selection behavior of a group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-selection-behavior"
}
}
},
{
"id": "PlanDefinition.action.requiredBehavior",
"path": "PlanDefinition.action.requiredBehavior",
"short": "must | could | must-unless-documented",
"definition": "Defines the requiredness behavior for the action.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionRequiredBehavior"
}
],
"strength": "required",
"description": "Defines requiredness behavior for selecting an action or an action group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-required-behavior"
}
}
},
{
"id": "PlanDefinition.action.precheckBehavior",
"path": "PlanDefinition.action.precheckBehavior",
"short": "yes | no",
"definition": "Defines whether the action should usually be preselected.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionPrecheckBehavior"
}
],
"strength": "required",
"description": "Defines selection frequency behavior for an action or group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-precheck-behavior"
}
}
},
{
"id": "PlanDefinition.action.cardinalityBehavior",
"path": "PlanDefinition.action.cardinalityBehavior",
"short": "single | multiple",
"definition": "Defines whether the action can be selected multiple times.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionCardinalityBehavior"
}
],
"strength": "required",
"description": "Defines behavior for an action or a group for how many times that item may be repeated",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-cardinality-behavior"
}
}
},
{
"id": "PlanDefinition.action.definition",
"path": "PlanDefinition.action.definition",
"short": "Description of the activity to be performed",
"definition": "A reference to an ActivityDefinition that describes the action to be taken in detail, or a PlanDefinition that describes a series of actions to be taken.",
"comment": "Note that the definition is optional, and if no definition is specified, a dynamicValue with a root (~) path can be used to define the entire resource dynamically.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.definition"
}
]
},
{
"id": "PlanDefinition.action.transform",
"path": "PlanDefinition.action.transform",
"short": "Transform to apply the template",
"definition": "A reference to a StructureMap resource that defines a transform that can be executed to produce the intent resource using the ActivityDefinition instance as the input.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/StructureMap"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue",
"path": "PlanDefinition.action.dynamicValue",
"short": "Dynamic aspects of the definition",
"definition": "Customizations that should be applied to the statically defined resource. For example, if the dosage of a medication must be computed based on the patient's weight, a customization would be used to specify an expression that calculated the weight, and the path on the resource that would contain the result.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue.id",
"path": "PlanDefinition.action.dynamicValue.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue.extension",
"path": "PlanDefinition.action.dynamicValue.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue.modifierExtension",
"path": "PlanDefinition.action.dynamicValue.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue.description",
"path": "PlanDefinition.action.dynamicValue.description",
"short": "Natural language description of the dynamic value",
"definition": "A brief, natural language description of the intended semantics of the dynamic value.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue.path",
"path": "PlanDefinition.action.dynamicValue.path",
"short": "The path to the element to be set dynamically",
"definition": "The path to the element to be customized. This is the path on the resource that will hold the result of the calculation defined by the expression.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue.language",
"path": "PlanDefinition.action.dynamicValue.language",
"short": "Language of the expression",
"definition": "The media type of the language for the expression.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue.expression",
"path": "PlanDefinition.action.dynamicValue.expression",
"short": "An expression that provides the dynamic value for the customization",
"definition": "An expression specifying the value of the customized element.",
"comment": "The expression may be inlined, or may be a reference to a named expression within a logic library referenced by the library element.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.action",
"path": "PlanDefinition.action.action",
"short": "A sub-action",
"definition": "Sub actions that are contained within the action. The behavior of this action determines the functionality of the sub-actions. For example, a selection behavior of at-most-one indicates that of the sub-actions, at most one may be chosen as part of realizing the action definition.",
"min": 0,
"max": "*",
"contentReference": "#PlanDefinition.action",
"mapping": [
{
"identity": "workflow",
"map": "InverseRelationship of Definition.partOf"
}
]
}
]
},
"differential": {
"element": [
{
"id": "PlanDefinition",
"path": "PlanDefinition",
"short": "The definition of a plan for a series of actions, independent of any specific patient or context",
"definition": "This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Definition"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "PlanDefinition.url",
"path": "PlanDefinition.url",
"short": "Logical URI to reference this plan definition (globally unique)",
"definition": "An absolute URI that is used to identify this plan definition when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this plan definition is (or will be) published. The URL SHOULD include the major version of the plan definition. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the plan definition to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.url"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "PlanDefinition.identifier",
"path": "PlanDefinition.identifier",
"short": "Additional identifier for the plan definition",
"definition": "A formal identifier that is used to identify this plan definition when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this plan definition outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.identifier"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "PlanDefinition.version",
"path": "PlanDefinition.version",
"short": "Business version of the plan definition",
"definition": "The identifier that is used to identify this version of the plan definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the plan definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge assets, refer to the Decision Support Service specification. Note that a version is required for non-experimental active artifacts.",
"comment": "There may be different plan definition instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the plan definition with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.version"
},
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "PlanDefinition.name",
"path": "PlanDefinition.name",
"short": "Name for this plan definition (computer friendly)",
"definition": "A natural language name identifying the plan definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "PlanDefinition.title",
"path": "PlanDefinition.title",
"short": "Name for this plan definition (human friendly)",
"definition": "A short, descriptive, user-friendly title for the plan definition.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.title"
}
]
},
{
"id": "PlanDefinition.type",
"path": "PlanDefinition.type",
"short": "order-set | protocol | eca-rule",
"definition": "The type of asset the plan definition represents, e.g. an order set, protocol, or event-condition-action rule.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PlanDefinitionType"
}
],
"strength": "extensible",
"description": "The type of PlanDefinition",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/plan-definition-type"
}
}
},
{
"id": "PlanDefinition.status",
"path": "PlanDefinition.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this plan definition. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of plan definitions that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired plan definition without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.status (different ValueSet)"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "PlanDefinition.experimental",
"path": "PlanDefinition.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this plan definition is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of plan definition that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental plan definition in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level plan definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.experimental"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "PlanDefinition.date",
"path": "PlanDefinition.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the plan definition was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the plan definition changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the plan definition. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.date"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "PlanDefinition.publisher",
"path": "PlanDefinition.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the plan definition.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the plan definition is the organization or individual primarily responsible for the maintenance and upkeep of the plan definition. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the plan definition. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the plan definition. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.publisher (as string instead of Reference)"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "PlanDefinition.description",
"path": "PlanDefinition.description",
"short": "Natural language description of the plan definition",
"definition": "A free text natural language description of the plan definition from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the plan definition was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the plan definition as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.description"
}
]
},
{
"id": "PlanDefinition.purpose",
"path": "PlanDefinition.purpose",
"short": "Why this plan definition is defined",
"definition": "Explaination of why this plan definition is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the plan definition Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this plan definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.purpose"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "PlanDefinition.usage",
"path": "PlanDefinition.usage",
"short": "Describes the clinical usage of the asset",
"definition": "A detailed description of how the asset is used from a clinical perspective.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.approvalDate",
"path": "PlanDefinition.approvalDate",
"short": "When the plan definition was approved by publisher",
"definition": "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.",
"comment": "The 'date' element may be more recent than the approval date because of minor changes / editorial corrections.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.approvalDate"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "PlanDefinition.lastReviewDate",
"path": "PlanDefinition.lastReviewDate",
"short": "When the plan definition was last reviewed",
"definition": "The date on which the resource content was last reviewed. Review happens periodically after approval, but doesn't change the original approval date.",
"comment": "If specified, this is usually after the approval date.",
"requirements": "Gives a sense of how \"current\" the content is. Resources that have not been reviewed in a long time may have a risk of being less appropriate/relevant.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.lastReviewDate"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "PlanDefinition.effectivePeriod",
"path": "PlanDefinition.effectivePeriod",
"short": "When the plan definition is expected to be used",
"definition": "The period during which the plan definition content was or is planned to be in active use.",
"comment": "The effective period for a plan definition determines when the content is applicable for usage and is independent of publication and review dates. For example, a measure intended to be used for the year 2016 might be published in 2015.",
"requirements": "Allows establishing a transition before a resource comes into effect and also allows for a sunsetting process when new versions of a the plan definition are or are expected to be used instead.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.effectivePeriod"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "PlanDefinition.useContext",
"path": "PlanDefinition.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate plan definition instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.useContext"
}
]
},
{
"id": "PlanDefinition.jurisdiction",
"path": "PlanDefinition.jurisdiction",
"short": "Intended jurisdiction for plan definition (if applicable)",
"definition": "A legal or geographic region in which the plan definition is intended to be used.",
"comment": "It may be possible for the plan definition to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.jurisdiction"
}
]
},
{
"id": "PlanDefinition.topic",
"path": "PlanDefinition.topic",
"short": "E.g. Education, Treatment, Assessment, etc",
"definition": "Descriptive topics related to the content of the plan definition. Topics provide a high-level categorization of the definition that can be useful for filtering and searching.",
"requirements": "Repositories must be able to determine how to categorize the asset so that it can be found by topical searches.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "DefinitionTopic"
}
],
"strength": "example",
"description": "High-level categorization of the definition, used for searching, sorting, and filtering",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/definition-topic"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.subjectCodableConcept"
}
]
},
{
"id": "PlanDefinition.contributor",
"path": "PlanDefinition.contributor",
"short": "A content contributor",
"definition": "A contributor to the content of the asset, including authors, editors, reviewers, and endorsers.",
"requirements": "Consumers of the content must be able to quickly determine who contributed to the content of the asset.",
"min": 0,
"max": "*",
"type": [
{
"code": "Contributor"
}
]
},
{
"id": "PlanDefinition.contact",
"path": "PlanDefinition.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.contact"
}
]
},
{
"id": "PlanDefinition.copyright",
"path": "PlanDefinition.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the plan definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the plan definition.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the plan definition and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.copyright"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "PlanDefinition.relatedArtifact",
"path": "PlanDefinition.relatedArtifact",
"short": "Related artifacts for the asset",
"definition": "Related artifacts such as additional documentation, justification, or bibliographic references.",
"comment": "Each related artifact is either an attachment, or a reference to another resource, but not both.",
"requirements": "Assets must be able to provide enough information for consumers of the content (and/or interventions or results produced by the content) to be able to determine and understand the justification for and evidence in support of the content.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
]
},
{
"id": "PlanDefinition.library",
"path": "PlanDefinition.library",
"short": "Logic used by the plan definition",
"definition": "A reference to a Library resource containing any formal logic used by the plan definition.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Library"
}
]
},
{
"id": "PlanDefinition.goal",
"path": "PlanDefinition.goal",
"short": "What the plan is trying to accomplish",
"definition": "Goals that describe what the activities within the plan are intended to achieve. For example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc.",
"requirements": "Goal information needs to be captured for order sets, protocols, and care plan definitions to better describe the objectives of the protocol activities and to guide the creation of specific goals within the derived care plans and orders.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "PlanDefinition.goal.category",
"path": "PlanDefinition.goal.category",
"short": "E.g. Treatment, dietary, behavioral, etc",
"definition": "Indicates a category the goal falls within.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalCategory"
}
],
"strength": "example",
"description": "Example codes for grouping goals for filtering or presentation",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/goal-category"
}
}
},
{
"id": "PlanDefinition.goal.description",
"path": "PlanDefinition.goal.description",
"short": "Code or text describing the goal",
"definition": "Human-readable and/or coded description of a specific desired objective of care, such as \"control blood pressure\" or \"negotiate an obstacle course\" or \"dance with child at wedding\".",
"comment": "If no code is available, use CodeableConcept.text.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalDescription"
}
],
"strength": "example",
"description": "Describes goals that can be achieved",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/clinical-findings"
}
}
},
{
"id": "PlanDefinition.goal.priority",
"path": "PlanDefinition.goal.priority",
"short": "high-priority | medium-priority | low-priority",
"definition": "Identifies the expected level of importance associated with reaching/sustaining the defined goal.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalPriority"
}
],
"strength": "preferred",
"description": "Indicates the level of importance associated with reaching or sustaining a goal",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/goal-priority"
}
}
},
{
"id": "PlanDefinition.goal.start",
"path": "PlanDefinition.goal.start",
"short": "When goal pursuit begins",
"definition": "The event after which the goal should begin being pursued.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalStartEvent"
}
],
"strength": "example",
"description": "Identifies the types of events that might trigger the start of a goal",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/goal-start-event"
}
}
},
{
"id": "PlanDefinition.goal.addresses",
"path": "PlanDefinition.goal.addresses",
"short": "What does the goal address",
"definition": "Identifies problems, conditions, issues, or concerns the goal is intended to address.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalAddresses"
}
],
"strength": "example",
"description": "Identifies problems, conditions, issues, or concerns that goals may address",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/condition-code"
}
}
},
{
"id": "PlanDefinition.goal.documentation",
"path": "PlanDefinition.goal.documentation",
"short": "Supporting documentation for the goal",
"definition": "Didactic or other informational resources associated with the goal that provide further supporting information about the goal. Information resources can include inline text commentary and links to web resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
]
},
{
"id": "PlanDefinition.goal.target",
"path": "PlanDefinition.goal.target",
"short": "Target outcome for the goal",
"definition": "Indicates what should be done and within what timeframe.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "PlanDefinition.goal.target.measure",
"path": "PlanDefinition.goal.target.measure",
"short": "The parameter whose value is to be tracked",
"definition": "The parameter whose value is to be tracked, e.g. body weigth, blood pressure, or hemoglobin A1c level.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "GoalTargetMeasure"
}
],
"strength": "example",
"description": "Identifies types of parameters that can be tracked to determine goal achievement",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-codes"
}
}
},
{
"id": "PlanDefinition.goal.target.detail[x]",
"path": "PlanDefinition.goal.target.detail[x]",
"short": "The target value to be achieved",
"definition": "The target value of the measure to be achieved to signify fulfillment of the goal, e.g. 150 pounds or 7.0%. Either the high or low or both values of the range can be specified. Whan a low value is missing, it indicates that the goal is achieved at any value at or below the high value. Similarly, if the high value is missing, it indicates that the goal is achieved at any value at or above the low value.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity"
},
{
"code": "Range"
},
{
"code": "CodeableConcept"
}
]
},
{
"id": "PlanDefinition.goal.target.due",
"path": "PlanDefinition.goal.target.due",
"short": "Reach goal within",
"definition": "Indicates the timeframe after the start of the goal in which the goal should be met.",
"min": 0,
"max": "1",
"type": [
{
"code": "Duration"
}
]
},
{
"id": "PlanDefinition.action",
"path": "PlanDefinition.action",
"short": "Action defined by the plan",
"definition": "An action to be taken as part of the plan.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Is a contained Definition"
}
]
},
{
"id": "PlanDefinition.action.label",
"path": "PlanDefinition.action.label",
"short": "User-visible label for the action (e.g. 1. or A.)",
"definition": "A user-visible label for the action.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.title",
"path": "PlanDefinition.action.title",
"short": "User-visible title",
"definition": "The title of the action displayed to a user.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.title"
}
]
},
{
"id": "PlanDefinition.action.description",
"path": "PlanDefinition.action.description",
"short": "Short description of the action",
"definition": "A short description of the action used to provide a summary to display to the user.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.description"
}
]
},
{
"id": "PlanDefinition.action.textEquivalent",
"path": "PlanDefinition.action.textEquivalent",
"short": "Static text equivalent of the action, used if the dynamic aspects cannot be interpreted by the receiving system",
"definition": "A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.description"
}
]
},
{
"id": "PlanDefinition.action.code",
"path": "PlanDefinition.action.code",
"short": "Code representing the meaning of the action or sub-actions",
"definition": "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
]
},
{
"id": "PlanDefinition.action.reason",
"path": "PlanDefinition.action.reason",
"short": "Why the action should be performed",
"definition": "A description of why this action is necessary or appropriate.",
"comment": "This is different than the clinical evidence documentation, it's an actual business description of the reason for performing the action.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
]
},
{
"id": "PlanDefinition.action.documentation",
"path": "PlanDefinition.action.documentation",
"short": "Supporting documentation for the intended performer of the action",
"definition": "Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
]
},
{
"id": "PlanDefinition.action.goalId",
"path": "PlanDefinition.action.goalId",
"short": "What goals this action supports",
"definition": "Identifies goals that this action supports. The reference must be to a goal element defined within this plan definition.",
"min": 0,
"max": "*",
"type": [
{
"code": "id"
}
]
},
{
"id": "PlanDefinition.action.triggerDefinition",
"path": "PlanDefinition.action.triggerDefinition",
"short": "When the action should be triggered",
"definition": "A description of when the action should be triggered.",
"min": 0,
"max": "*",
"type": [
{
"code": "TriggerDefinition"
}
]
},
{
"id": "PlanDefinition.action.condition",
"path": "PlanDefinition.action.condition",
"short": "Whether or not the action is applicable",
"definition": "An expression that describes applicability criteria, or start/stop conditions for the action.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "PlanDefinition.action.condition.kind",
"path": "PlanDefinition.action.condition.kind",
"short": "applicability | start | stop",
"definition": "The kind of condition.",
"comment": "Applicability criteria are used to determine immediate applicability when a plan definition is applied to a given context. Start and stop criteria are carried through application and used to describe when enter/exit criteria for an action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionConditionKind"
}
],
"strength": "required",
"description": "Defines the kinds of conditions that can appear on actions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-condition-kind"
}
}
},
{
"id": "PlanDefinition.action.condition.description",
"path": "PlanDefinition.action.condition.description",
"short": "Natural language description of the condition",
"definition": "A brief, natural language description of the condition that effectively communicates the intended semantics.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.condition.language",
"path": "PlanDefinition.action.condition.language",
"short": "Language of the expression",
"definition": "The media type of the language for the expression.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.condition.expression",
"path": "PlanDefinition.action.condition.expression",
"short": "Boolean-valued expression",
"definition": "An expression that returns true or false, indicating whether or not the condition is satisfied.",
"comment": "The expression may be inlined, or may be a reference to a named expression within a logic library referenced by the library element.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.input",
"path": "PlanDefinition.action.input",
"short": "Input data requirements",
"definition": "Defines input data requirements for the action.",
"min": 0,
"max": "*",
"type": [
{
"code": "DataRequirement"
}
]
},
{
"id": "PlanDefinition.action.output",
"path": "PlanDefinition.action.output",
"short": "Output data definition",
"definition": "Defines the outputs of the action, if any.",
"min": 0,
"max": "*",
"type": [
{
"code": "DataRequirement"
}
]
},
{
"id": "PlanDefinition.action.relatedAction",
"path": "PlanDefinition.action.relatedAction",
"short": "Relationship to another action",
"definition": "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".",
"comment": "When an action depends on multiple actions, the meaning is that all actions are dependencies, rather than that any of the actions are a dependency.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "PlanDefinition.action.relatedAction.actionId",
"path": "PlanDefinition.action.relatedAction.actionId",
"short": "What action is this related to",
"definition": "The element id of the related action.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "PlanDefinition.action.relatedAction.relationship",
"path": "PlanDefinition.action.relatedAction.relationship",
"short": "before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end",
"definition": "The relationship of this action to the related action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionRelationshipType"
}
],
"strength": "required",
"description": "Defines the types of relationships between actions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-relationship-type"
}
}
},
{
"id": "PlanDefinition.action.relatedAction.offset[x]",
"path": "PlanDefinition.action.relatedAction.offset[x]",
"short": "Time offset for the relationship",
"definition": "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.",
"min": 0,
"max": "1",
"type": [
{
"code": "Duration"
},
{
"code": "Range"
}
]
},
{
"id": "PlanDefinition.action.timing[x]",
"path": "PlanDefinition.action.timing[x]",
"short": "When the action should take place",
"definition": "An optional value describing when the action should be performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
},
{
"code": "Duration"
},
{
"code": "Range"
},
{
"code": "Timing"
}
]
},
{
"id": "PlanDefinition.action.participant",
"path": "PlanDefinition.action.participant",
"short": "Who should participate in the action",
"definition": "Indicates who should participate in performing the action described.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "PlanDefinition.action.participant.type",
"path": "PlanDefinition.action.participant.type",
"short": "patient | practitioner | related-person",
"definition": "The type of participant in the action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionParticipantType"
}
],
"strength": "required",
"description": "The type of participant for the action",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-participant-type"
}
}
},
{
"id": "PlanDefinition.action.participant.role",
"path": "PlanDefinition.action.participant.role",
"short": "E.g. Nurse, Surgeon, Parent, etc",
"definition": "The role the participant should play in performing the described action.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionParticipantRole"
}
],
"strength": "example",
"description": "Defines roles played by participants for the action",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-participant-role"
}
}
},
{
"id": "PlanDefinition.action.type",
"path": "PlanDefinition.action.type",
"short": "create | update | remove | fire-event",
"definition": "The type of action to perform (create, update, remove).",
"min": 0,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionType"
}
],
"strength": "required",
"description": "The type of action to be performed",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-type"
}
}
},
{
"id": "PlanDefinition.action.groupingBehavior",
"path": "PlanDefinition.action.groupingBehavior",
"short": "visual-group | logical-group | sentence-group",
"definition": "Defines the grouping behavior for the action and its children.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionGroupingBehavior"
}
],
"strength": "required",
"description": "Defines organization behavior of a group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-grouping-behavior"
}
}
},
{
"id": "PlanDefinition.action.selectionBehavior",
"path": "PlanDefinition.action.selectionBehavior",
"short": "any | all | all-or-none | exactly-one | at-most-one | one-or-more",
"definition": "Defines the selection behavior for the action and its children.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionSelectionBehavior"
}
],
"strength": "required",
"description": "Defines selection behavior of a group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-selection-behavior"
}
}
},
{
"id": "PlanDefinition.action.requiredBehavior",
"path": "PlanDefinition.action.requiredBehavior",
"short": "must | could | must-unless-documented",
"definition": "Defines the requiredness behavior for the action.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionRequiredBehavior"
}
],
"strength": "required",
"description": "Defines requiredness behavior for selecting an action or an action group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-required-behavior"
}
}
},
{
"id": "PlanDefinition.action.precheckBehavior",
"path": "PlanDefinition.action.precheckBehavior",
"short": "yes | no",
"definition": "Defines whether the action should usually be preselected.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionPrecheckBehavior"
}
],
"strength": "required",
"description": "Defines selection frequency behavior for an action or group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-precheck-behavior"
}
}
},
{
"id": "PlanDefinition.action.cardinalityBehavior",
"path": "PlanDefinition.action.cardinalityBehavior",
"short": "single | multiple",
"definition": "Defines whether the action can be selected multiple times.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionCardinalityBehavior"
}
],
"strength": "required",
"description": "Defines behavior for an action or a group for how many times that item may be repeated",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-cardinality-behavior"
}
}
},
{
"id": "PlanDefinition.action.definition",
"path": "PlanDefinition.action.definition",
"short": "Description of the activity to be performed",
"definition": "A reference to an ActivityDefinition that describes the action to be taken in detail, or a PlanDefinition that describes a series of actions to be taken.",
"comment": "Note that the definition is optional, and if no definition is specified, a dynamicValue with a root (~) path can be used to define the entire resource dynamically.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.definition"
}
]
},
{
"id": "PlanDefinition.action.transform",
"path": "PlanDefinition.action.transform",
"short": "Transform to apply the template",
"definition": "A reference to a StructureMap resource that defines a transform that can be executed to produce the intent resource using the ActivityDefinition instance as the input.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/StructureMap"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue",
"path": "PlanDefinition.action.dynamicValue",
"short": "Dynamic aspects of the definition",
"definition": "Customizations that should be applied to the statically defined resource. For example, if the dosage of a medication must be computed based on the patient's weight, a customization would be used to specify an expression that calculated the weight, and the path on the resource that would contain the result.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue.description",
"path": "PlanDefinition.action.dynamicValue.description",
"short": "Natural language description of the dynamic value",
"definition": "A brief, natural language description of the intended semantics of the dynamic value.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue.path",
"path": "PlanDefinition.action.dynamicValue.path",
"short": "The path to the element to be set dynamically",
"definition": "The path to the element to be customized. This is the path on the resource that will hold the result of the calculation defined by the expression.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue.language",
"path": "PlanDefinition.action.dynamicValue.language",
"short": "Language of the expression",
"definition": "The media type of the language for the expression.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.dynamicValue.expression",
"path": "PlanDefinition.action.dynamicValue.expression",
"short": "An expression that provides the dynamic value for the customization",
"definition": "An expression specifying the value of the customized element.",
"comment": "The expression may be inlined, or may be a reference to a named expression within a logic library referenced by the library element.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "PlanDefinition.action.action",
"path": "PlanDefinition.action.action",
"short": "A sub-action",
"definition": "Sub actions that are contained within the action. The behavior of this action determines the functionality of the sub-actions. For example, a selection behavior of at-most-one indicates that of the sub-actions, at most one may be chosen as part of realizing the action definition.",
"min": 0,
"max": "*",
"contentReference": "#PlanDefinition.action",
"mapping": [
{
"identity": "workflow",
"map": "InverseRelationship of Definition.partOf"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Practitioner",
"resource": {
"resourceType": "StructureDefinition",
"id": "Practitioner",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Practitioner DomainResource A person with a formal responsibility in the provisioning of healthcare or related services
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier A identifier for the person as this agent
active Σ 0..1 boolean Whether this practitioner's record is in active use name Σ 0..* HumanName The name(s) associated with the practitioner
telecom Σ 0..* ContactPoint A contact detail for the practitioner (that apply to all roles)
address Σ 0..* Address Address(es) of the practitioner that are not role specific (typically home address)
gender Σ 0..1 code male | female | other | unknown
AdministrativeGender (Required) birthDate Σ 0..1 date The date on which the practitioner was born photo 0..* Attachment Image of the person
qualification 0..* BackboneElement Qualifications obtained by training and certification
identifier 0..* Identifier An identifier for this qualification for the practitioner
code 1..1 CodeableConcept Coded representation of the qualification
v2 table 0360, Version 2.7 (Example) period 0..1 Period Period during which the qualification is valid issuer 0..1 Reference(Organization) Organization that regulates and issues the qualification communication 0..* CodeableConcept A language the practitioner is able to use in patient communication
Common Languages (Extensible but limited to All Languages)
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "pa"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Practitioner",
"name": "Practitioner",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Patient Administration)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/pafm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Practitioner Resource",
"purpose": "Need to track doctors, staff, locums etc. for both healthcare practitioners, funders, etc.",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "servd",
"uri": "http://www.omg.org/spec/ServD/1.0/",
"name": "ServD"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Practitioner",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Practitioner",
"path": "Practitioner",
"short": "A person with a formal responsibility in the provisioning of healthcare or related services",
"definition": "A person who is directly or indirectly involved in the provisioning of healthcare.",
"comment": "Note that a cab driver no longer fits the bill. You probably would be interested in the organization rather than the individual?",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "v2",
"map": "PRD (as one example)"
},
{
"identity": "rim",
"map": "Role"
},
{
"identity": "servd",
"map": "Provider"
},
{
"identity": "w5",
"map": "administrative.individual"
}
]
},
{
"id": "Practitioner.id",
"path": "Practitioner.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Practitioner.meta",
"path": "Practitioner.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Practitioner.implicitRules",
"path": "Practitioner.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Practitioner.language",
"path": "Practitioner.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Practitioner.text",
"path": "Practitioner.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Practitioner.contained",
"path": "Practitioner.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Practitioner.extension",
"path": "Practitioner.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Practitioner.modifierExtension",
"path": "Practitioner.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Practitioner.identifier",
"path": "Practitioner.identifier",
"short": "A identifier for the person as this agent",
"definition": "An identifier that applies to this person in this role.",
"requirements": "Often, specific identities are assigned for the agent.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRD-7 (or XCN.1)"
},
{
"identity": "rim",
"map": "./id"
},
{
"identity": "servd",
"map": "./Identifiers"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Practitioner.active",
"path": "Practitioner.active",
"short": "Whether this practitioner's record is in active use",
"definition": "Whether this practitioner's record is in active use.",
"comment": "Default is true. \r\rIf the practitioner is not in use by one organization, then it should mark the period on the PractitonerRole with an end date (even if they are active) as they may be active in another role.",
"requirements": "Need to be able to mark a practitioner record as not to be used because it was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "./statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Practitioner.name",
"path": "Practitioner.name",
"short": "The name(s) associated with the practitioner",
"definition": "The name(s) associated with the practitioner.",
"comment": "The selection of the use property should ensure that there is a single usual name specified, and others use the nickname (alias), old, or other values as appropriate.\r\rIn general select the value to be used in the ResourceReference.display based on this:\r\r1. There is more than 1 name\r2. Use = usual\r3. Period is current to the date of the usage\r4. Use = official\r5. Other order as decided by internal business rules.",
"requirements": "The name(s) that a Practitioner is known by. Where there are multiple, the name that the practitioner is usually known as should be used in the display.",
"min": 0,
"max": "*",
"type": [
{
"code": "HumanName"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "XCN Components"
},
{
"identity": "rim",
"map": "./name"
},
{
"identity": "servd",
"map": "./PreferredName (GivenNames, FamilyName, TitleCode)"
}
]
},
{
"id": "Practitioner.telecom",
"path": "Practitioner.telecom",
"short": "A contact detail for the practitioner (that apply to all roles)",
"definition": "A contact detail for the practitioner, e.g. a telephone number or an email address.",
"comment": "Person may have multiple ways to be contacted with different uses or applicable periods. May need to have options for contacting the person urgently, and also to help with identification\r\rThese typically will have home numbers, or mobile numbers that are not role specific.",
"requirements": "Need to know how to reach a practitioner independent to any roles the practitioner may have.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRT-15, STF-10, ROL-12"
},
{
"identity": "rim",
"map": "./telecom"
},
{
"identity": "servd",
"map": "./ContactPoints"
}
]
},
{
"id": "Practitioner.address",
"path": "Practitioner.address",
"short": "Address(es) of the practitioner that are not role specific (typically home address)",
"definition": "Address(es) of the practitioner that are not role specific (typically home address). \rWork addresses are not typically entered in this property as they are usually role dependent.",
"comment": "The PractitionerRole does not have an address value on it, as it is expected that the location property be used for this purpose (which has an address).",
"requirements": "The home/mailing address of the practitioner is often required for employee administration purposes, and also for some rostering services where the start point (practitioners home) can be used in calculations.",
"min": 0,
"max": "*",
"type": [
{
"code": "Address"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ORC-24, STF-11, ROL-11, PRT-14"
},
{
"identity": "rim",
"map": "./addr"
},
{
"identity": "servd",
"map": "./Addresses"
}
]
},
{
"id": "Practitioner.gender",
"path": "Practitioner.gender",
"short": "male | female | other | unknown",
"definition": "Administrative Gender - the gender that the person is considered to have for administration and record keeping purposes.",
"requirements": "Needed to address the person correctly.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdministrativeGender"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The gender of a person used for administrative purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administrative-gender"
}
},
"mapping": [
{
"identity": "v2",
"map": "STF-5"
},
{
"identity": "rim",
"map": "./administrativeGender"
},
{
"identity": "servd",
"map": "./GenderCode"
}
]
},
{
"id": "Practitioner.birthDate",
"path": "Practitioner.birthDate",
"short": "The date on which the practitioner was born",
"definition": "The date of birth for the practitioner.",
"requirements": "Needed for identification.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "STF-6"
},
{
"identity": "rim",
"map": "./birthTime"
},
{
"identity": "servd",
"map": "(not represented in ServD)"
}
]
},
{
"id": "Practitioner.photo",
"path": "Practitioner.photo",
"short": "Image of the person",
"definition": "Image of the person.",
"requirements": "Many EHR systems have the capability to capture an image of patients and personnel. Fits with newer social media usage too.",
"min": 0,
"max": "*",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "rim",
"map": "./subjectOf/ObservationEvent[code=\"photo\"]/value"
},
{
"identity": "servd",
"map": "./ImageURI (only supports the URI reference)"
}
]
},
{
"id": "Practitioner.qualification",
"path": "Practitioner.qualification",
"short": "Qualifications obtained by training and certification",
"definition": "Qualifications obtained by training and certification.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "v2",
"map": "CER?"
},
{
"identity": "rim",
"map": ".playingEntity.playingRole[classCode=QUAL].code"
},
{
"identity": "servd",
"map": "./Qualifications"
}
]
},
{
"id": "Practitioner.qualification.id",
"path": "Practitioner.qualification.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Practitioner.qualification.extension",
"path": "Practitioner.qualification.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Practitioner.qualification.modifierExtension",
"path": "Practitioner.qualification.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Practitioner.qualification.identifier",
"path": "Practitioner.qualification.identifier",
"short": "An identifier for this qualification for the practitioner",
"definition": "An identifier that applies to this person's qualification in this role.",
"requirements": "Often, specific identities are assigned for the qualification.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "rim",
"map": ".playingEntity.playingRole[classCode=QUAL].id"
}
]
},
{
"id": "Practitioner.qualification.code",
"path": "Practitioner.qualification.code",
"short": "Coded representation of the qualification",
"definition": "Coded representation of the qualification.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Qualification"
}
],
"strength": "example",
"description": "Specific qualification the practitioner has to provide a service",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v2-2.7-0360"
}
},
"mapping": [
{
"identity": "rim",
"map": ".playingEntity.playingRole[classCode=QUAL].code"
},
{
"identity": "servd",
"map": "./Qualifications.Value"
}
]
},
{
"id": "Practitioner.qualification.period",
"path": "Practitioner.qualification.period",
"short": "Period during which the qualification is valid",
"definition": "Period during which the qualification is valid.",
"requirements": "Qualifications are often for a limited period of time, and can be revoked.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": ".playingEntity.playingRole[classCode=QUAL].effectiveTime"
},
{
"identity": "servd",
"map": "./Qualifications.StartDate and ./Qualifications.EndDate"
}
]
},
{
"id": "Practitioner.qualification.issuer",
"path": "Practitioner.qualification.issuer",
"short": "Organization that regulates and issues the qualification",
"definition": "Organization that regulates and issues the qualification.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": ".playingEntity.playingRole[classCode=QUAL].scoper"
}
]
},
{
"id": "Practitioner.communication",
"path": "Practitioner.communication",
"short": "A language the practitioner is able to use in patient communication",
"definition": "A language the practitioner is able to use in patient communication.",
"comment": "The structure aa-BB with this exact casing is one the most widely used notations for locale. However not all systems actually code this but instead have it as free text. Hence CodeableConcept instead of code as the data type.",
"requirements": "Knowing which language a practitioner speaks can help in facilitating communication with patients.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-15, NK1-20, LAN-2"
},
{
"identity": "rim",
"map": "./languageCommunication"
},
{
"identity": "servd",
"map": "./Languages.LanguageSpokenCode"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Practitioner",
"path": "Practitioner",
"short": "A person with a formal responsibility in the provisioning of healthcare or related services",
"definition": "A person who is directly or indirectly involved in the provisioning of healthcare.",
"comment": "Note that a cab driver no longer fits the bill. You probably would be interested in the organization rather than the individual?",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "v2",
"map": "PRD (as one example)"
},
{
"identity": "rim",
"map": "Role"
},
{
"identity": "servd",
"map": "Provider"
},
{
"identity": "w5",
"map": "administrative.individual"
}
]
},
{
"id": "Practitioner.identifier",
"path": "Practitioner.identifier",
"short": "A identifier for the person as this agent",
"definition": "An identifier that applies to this person in this role.",
"requirements": "Often, specific identities are assigned for the agent.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRD-7 (or XCN.1)"
},
{
"identity": "rim",
"map": "./id"
},
{
"identity": "servd",
"map": "./Identifiers"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Practitioner.active",
"path": "Practitioner.active",
"short": "Whether this practitioner's record is in active use",
"definition": "Whether this practitioner's record is in active use.",
"comment": "Default is true. \r\rIf the practitioner is not in use by one organization, then it should mark the period on the PractitonerRole with an end date (even if they are active) as they may be active in another role.",
"requirements": "Need to be able to mark a practitioner record as not to be used because it was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "./statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Practitioner.name",
"path": "Practitioner.name",
"short": "The name(s) associated with the practitioner",
"definition": "The name(s) associated with the practitioner.",
"comment": "The selection of the use property should ensure that there is a single usual name specified, and others use the nickname (alias), old, or other values as appropriate.\r\rIn general select the value to be used in the ResourceReference.display based on this:\r\r1. There is more than 1 name\r2. Use = usual\r3. Period is current to the date of the usage\r4. Use = official\r5. Other order as decided by internal business rules.",
"requirements": "The name(s) that a Practitioner is known by. Where there are multiple, the name that the practitioner is usually known as should be used in the display.",
"min": 0,
"max": "*",
"type": [
{
"code": "HumanName"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "XCN Components"
},
{
"identity": "rim",
"map": "./name"
},
{
"identity": "servd",
"map": "./PreferredName (GivenNames, FamilyName, TitleCode)"
}
]
},
{
"id": "Practitioner.telecom",
"path": "Practitioner.telecom",
"short": "A contact detail for the practitioner (that apply to all roles)",
"definition": "A contact detail for the practitioner, e.g. a telephone number or an email address.",
"comment": "Person may have multiple ways to be contacted with different uses or applicable periods. May need to have options for contacting the person urgently, and also to help with identification\r\rThese typically will have home numbers, or mobile numbers that are not role specific.",
"requirements": "Need to know how to reach a practitioner independent to any roles the practitioner may have.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRT-15, STF-10, ROL-12"
},
{
"identity": "rim",
"map": "./telecom"
},
{
"identity": "servd",
"map": "./ContactPoints"
}
]
},
{
"id": "Practitioner.address",
"path": "Practitioner.address",
"short": "Address(es) of the practitioner that are not role specific (typically home address)",
"definition": "Address(es) of the practitioner that are not role specific (typically home address). \rWork addresses are not typically entered in this property as they are usually role dependent.",
"comment": "The PractitionerRole does not have an address value on it, as it is expected that the location property be used for this purpose (which has an address).",
"requirements": "The home/mailing address of the practitioner is often required for employee administration purposes, and also for some rostering services where the start point (practitioners home) can be used in calculations.",
"min": 0,
"max": "*",
"type": [
{
"code": "Address"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ORC-24, STF-11, ROL-11, PRT-14"
},
{
"identity": "rim",
"map": "./addr"
},
{
"identity": "servd",
"map": "./Addresses"
}
]
},
{
"id": "Practitioner.gender",
"path": "Practitioner.gender",
"short": "male | female | other | unknown",
"definition": "Administrative Gender - the gender that the person is considered to have for administration and record keeping purposes.",
"requirements": "Needed to address the person correctly.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdministrativeGender"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The gender of a person used for administrative purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administrative-gender"
}
},
"mapping": [
{
"identity": "v2",
"map": "STF-5"
},
{
"identity": "rim",
"map": "./administrativeGender"
},
{
"identity": "servd",
"map": "./GenderCode"
}
]
},
{
"id": "Practitioner.birthDate",
"path": "Practitioner.birthDate",
"short": "The date on which the practitioner was born",
"definition": "The date of birth for the practitioner.",
"requirements": "Needed for identification.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "STF-6"
},
{
"identity": "rim",
"map": "./birthTime"
},
{
"identity": "servd",
"map": "(not represented in ServD)"
}
]
},
{
"id": "Practitioner.photo",
"path": "Practitioner.photo",
"short": "Image of the person",
"definition": "Image of the person.",
"requirements": "Many EHR systems have the capability to capture an image of patients and personnel. Fits with newer social media usage too.",
"min": 0,
"max": "*",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "rim",
"map": "./subjectOf/ObservationEvent[code=\"photo\"]/value"
},
{
"identity": "servd",
"map": "./ImageURI (only supports the URI reference)"
}
]
},
{
"id": "Practitioner.qualification",
"path": "Practitioner.qualification",
"short": "Qualifications obtained by training and certification",
"definition": "Qualifications obtained by training and certification.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "v2",
"map": "CER?"
},
{
"identity": "rim",
"map": ".playingEntity.playingRole[classCode=QUAL].code"
},
{
"identity": "servd",
"map": "./Qualifications"
}
]
},
{
"id": "Practitioner.qualification.identifier",
"path": "Practitioner.qualification.identifier",
"short": "An identifier for this qualification for the practitioner",
"definition": "An identifier that applies to this person's qualification in this role.",
"requirements": "Often, specific identities are assigned for the qualification.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "rim",
"map": ".playingEntity.playingRole[classCode=QUAL].id"
}
]
},
{
"id": "Practitioner.qualification.code",
"path": "Practitioner.qualification.code",
"short": "Coded representation of the qualification",
"definition": "Coded representation of the qualification.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Qualification"
}
],
"strength": "example",
"description": "Specific qualification the practitioner has to provide a service",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v2-2.7-0360"
}
},
"mapping": [
{
"identity": "rim",
"map": ".playingEntity.playingRole[classCode=QUAL].code"
},
{
"identity": "servd",
"map": "./Qualifications.Value"
}
]
},
{
"id": "Practitioner.qualification.period",
"path": "Practitioner.qualification.period",
"short": "Period during which the qualification is valid",
"definition": "Period during which the qualification is valid.",
"requirements": "Qualifications are often for a limited period of time, and can be revoked.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": ".playingEntity.playingRole[classCode=QUAL].effectiveTime"
},
{
"identity": "servd",
"map": "./Qualifications.StartDate and ./Qualifications.EndDate"
}
]
},
{
"id": "Practitioner.qualification.issuer",
"path": "Practitioner.qualification.issuer",
"short": "Organization that regulates and issues the qualification",
"definition": "Organization that regulates and issues the qualification.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": ".playingEntity.playingRole[classCode=QUAL].scoper"
}
]
},
{
"id": "Practitioner.communication",
"path": "Practitioner.communication",
"short": "A language the practitioner is able to use in patient communication",
"definition": "A language the practitioner is able to use in patient communication.",
"comment": "The structure aa-BB with this exact casing is one the most widely used notations for locale. However not all systems actually code this but instead have it as free text. Hence CodeableConcept instead of code as the data type.",
"requirements": "Knowing which language a practitioner speaks can help in facilitating communication with patients.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
},
"mapping": [
{
"identity": "v2",
"map": "PID-15, NK1-20, LAN-2"
},
{
"identity": "rim",
"map": "./languageCommunication"
},
{
"identity": "servd",
"map": "./Languages.LanguageSpokenCode"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/PractitionerRole",
"resource": {
"resourceType": "StructureDefinition",
"id": "PractitionerRole",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints PractitionerRole DomainResource Roles/organizations the practitioner is associated with
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier Business Identifiers that are specific to a role/location
active Σ 0..1 boolean Whether this practitioner's record is in active use period Σ 0..1 Period The period during which the practitioner is authorized to perform in these role(s) practitioner Σ 0..1 Reference(Practitioner) Practitioner that is able to provide the defined services for the organation organization Σ 0..1 Reference(Organization) Organization where the roles are available code Σ 0..* CodeableConcept Roles which this practitioner may perform
PractitionerRole (Example)
specialty Σ 0..* CodeableConcept Specific specialty of the practitioner
Practice Setting Code Value Set (Preferred)
location Σ 0..* Reference(Location) The location(s) at which this practitioner provides care
healthcareService 0..* Reference(HealthcareService) The list of healthcare services that this worker provides for this role's Organization/Location(s)
telecom Σ 0..* ContactPoint Contact details that are specific to the role/location/service
availableTime 0..* BackboneElement Times the Service Site is available
daysOfWeek 0..* code mon | tue | wed | thu | fri | sat | sun
DaysOfWeek (Required)
allDay 0..1 boolean Always available? e.g. 24 hour service availableStartTime 0..1 time Opening time of day (ignored if allDay = true) availableEndTime 0..1 time Closing time of day (ignored if allDay = true) notAvailable 0..* BackboneElement Not available during this time due to provided reason
description 1..1 string Reason presented to the user explaining why time not available during 0..1 Period Service not availablefrom this date availabilityExceptions 0..1 string Description of availability exceptions endpoint 0..* Reference(Endpoint) Technical endpoints providing access to services operated for the practitioner with this role
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "pa"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/PractitionerRole",
"name": "PractitionerRole",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Patient Administration)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/pafm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for PractitionerRole Resource",
"purpose": "Need to track services that a healthcare provider is able to provide at an organization's location, and the services that they can perform there.",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "servd",
"uri": "http://www.omg.org/spec/ServD/1.0/",
"name": "ServD"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "PractitionerRole",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "PractitionerRole",
"path": "PractitionerRole",
"short": "Roles/organizations the practitioner is associated with",
"definition": "A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "v2",
"map": "PRD (as one example)"
},
{
"identity": "rim",
"map": "Role"
},
{
"identity": "servd",
"map": "ServiceSiteProvider"
},
{
"identity": "w5",
"map": "administrative.individual"
}
]
},
{
"id": "PractitionerRole.id",
"path": "PractitionerRole.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "PractitionerRole.meta",
"path": "PractitionerRole.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "PractitionerRole.implicitRules",
"path": "PractitionerRole.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "PractitionerRole.language",
"path": "PractitionerRole.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "PractitionerRole.text",
"path": "PractitionerRole.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "PractitionerRole.contained",
"path": "PractitionerRole.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PractitionerRole.extension",
"path": "PractitionerRole.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PractitionerRole.modifierExtension",
"path": "PractitionerRole.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PractitionerRole.identifier",
"path": "PractitionerRole.identifier",
"short": "Business Identifiers that are specific to a role/location",
"definition": "Business Identifiers that are specific to a role/location.",
"requirements": "Often, specific identities are assigned for the agent.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRD-7 (or XCN.1)"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "servd",
"map": "./Identifiers"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "PractitionerRole.active",
"path": "PractitionerRole.active",
"short": "Whether this practitioner's record is in active use",
"definition": "Whether this practitioner's record is in active use.",
"comment": "Default is true. \r\rIf the practitioner is not in use by one organization, then it should mark the period on the PractitonerRole with an end date (even if they are active) as they may be active in another role.",
"requirements": "Need to be able to mark a practitioner record as not to be used because it was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "STF-7"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "PractitionerRole.period",
"path": "PractitionerRole.period",
"short": "The period during which the practitioner is authorized to perform in these role(s)",
"definition": "The period during which the person is authorized to act as a practitioner in these role(s) for the organization.",
"requirements": "Even after the agencies is revoked, the fact that it existed must still be recorded.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRD-8/9 / PRA-5.4"
},
{
"identity": "rim",
"map": ".performance[@typeCode <= 'PPRF'].ActDefinitionOrEvent.effectiveTime"
},
{
"identity": "servd",
"map": "(ServD maps Practitioners and Organizations via another entity, so this concept is not available)"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "PractitionerRole.practitioner",
"path": "PractitionerRole.practitioner",
"short": "Practitioner that is able to provide the defined services for the organation",
"definition": "Practitioner that is able to provide the defined services for the organation.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player"
}
]
},
{
"id": "PractitionerRole.organization",
"path": "PractitionerRole.organization",
"short": "Organization where the roles are available",
"definition": "The organization where the Practitioner performs the roles associated.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "PractitionerRole.code",
"path": "PractitionerRole.code",
"short": "Roles which this practitioner may perform",
"definition": "Roles which this practitioner is authorized to perform for the organization.",
"comment": "A person may have more than one role. At least one role is required.",
"requirements": "Need to know what authority the practitioner has - what can they do?",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PractitionerRole"
}
],
"strength": "example",
"description": "The role a person plays representing an organization",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/practitioner-role"
}
},
"mapping": [
{
"identity": "v2",
"map": "PRD-1 / STF-18 / PRA-3 / PRT-4 / ROL-3 / ORC-12 / OBR-16 / PV1-7 / PV1-8 / PV1-9 / PV1-17"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "servd",
"map": "(ServD maps Practitioners and Organizations via another entity, so this concept is not available)"
}
]
},
{
"id": "PractitionerRole.specialty",
"path": "PractitionerRole.specialty",
"short": "Specific specialty of the practitioner",
"definition": "Specific specialty of the practitioner.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PractitionerSpecialty"
}
],
"strength": "preferred",
"description": "Specific specialty associated with the agency",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/c80-practice-codes"
}
},
"mapping": [
{
"identity": "v2",
"map": "PRA-5"
},
{
"identity": "rim",
"map": ".player.HealthCareProvider[@classCode = 'PROV'].code"
},
{
"identity": "servd",
"map": "./Specialty"
}
]
},
{
"id": "PractitionerRole.location",
"path": "PractitionerRole.location",
"short": "The location(s) at which this practitioner provides care",
"definition": "The location(s) at which this practitioner provides care.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".performance.ActDefinitionOrEvent.ServiceDeliveryLocation[@classCode = 'SDLOC']"
},
{
"identity": "servd",
"map": "(ServD maps Practitioners and Organizations via another entity, so this concept is not available)
However these are accessed via the Site.ServiceSite.ServiceSiteProvider record. (The Site has the location)"
},
{
"identity": "w5",
"map": "where"
}
]
},
{
"id": "PractitionerRole.healthcareService",
"path": "PractitionerRole.healthcareService",
"short": "The list of healthcare services that this worker provides for this role's Organization/Location(s)",
"definition": "The list of healthcare services that this worker provides for this role's Organization/Location(s).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/HealthcareService"
}
],
"mapping": [
{
"identity": "v2",
"map": "EDU-2 / AFF-3"
},
{
"identity": "rim",
"map": ".player.QualifiedEntity[@classCode = 'QUAL'].code"
}
]
},
{
"id": "PractitionerRole.telecom",
"path": "PractitionerRole.telecom",
"short": "Contact details that are specific to the role/location/service",
"definition": "Contact details that are specific to the role/location/service.",
"requirements": "Often practitioners have a dedicated line for each location (or service) that they work at, and need to be able to define separate contact details for each of these.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".telecom"
}
]
},
{
"id": "PractitionerRole.availableTime",
"path": "PractitionerRole.availableTime",
"short": "Times the Service Site is available",
"definition": "A collection of times that the Service Site is available.",
"comment": "More detailed availability information may be provided in associated Schedule/Slot resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.availableTime.id",
"path": "PractitionerRole.availableTime.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PractitionerRole.availableTime.extension",
"path": "PractitionerRole.availableTime.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PractitionerRole.availableTime.modifierExtension",
"path": "PractitionerRole.availableTime.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PractitionerRole.availableTime.daysOfWeek",
"path": "PractitionerRole.availableTime.daysOfWeek",
"short": "mon | tue | wed | thu | fri | sat | sun",
"definition": "Indicates which days of the week are available between the start and end Times.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "DaysOfWeek"
}
],
"strength": "required",
"description": "The days of the week.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/days-of-week"
}
},
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.availableTime.allDay",
"path": "PractitionerRole.availableTime.allDay",
"short": "Always available? e.g. 24 hour service",
"definition": "Is this always available? (hence times are irrelevant) e.g. 24 hour service.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.availableTime.availableStartTime",
"path": "PractitionerRole.availableTime.availableStartTime",
"short": "Opening time of day (ignored if allDay = true)",
"definition": "The opening time of day. Note: If the AllDay flag is set, then this time is ignored.",
"comment": "The timezone is expected to be for where this HealthcareService is provided at.",
"min": 0,
"max": "1",
"type": [
{
"code": "time"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.availableTime.availableEndTime",
"path": "PractitionerRole.availableTime.availableEndTime",
"short": "Closing time of day (ignored if allDay = true)",
"definition": "The closing time of day. Note: If the AllDay flag is set, then this time is ignored.",
"comment": "The timezone is expected to be for where this HealthcareService is provided at.",
"min": 0,
"max": "1",
"type": [
{
"code": "time"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.notAvailable",
"path": "PractitionerRole.notAvailable",
"short": "Not available during this time due to provided reason",
"definition": "The HealthcareService is not available during this period of time due to the provided reason.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.notAvailable.id",
"path": "PractitionerRole.notAvailable.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PractitionerRole.notAvailable.extension",
"path": "PractitionerRole.notAvailable.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PractitionerRole.notAvailable.modifierExtension",
"path": "PractitionerRole.notAvailable.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "PractitionerRole.notAvailable.description",
"path": "PractitionerRole.notAvailable.description",
"short": "Reason presented to the user explaining why time not available",
"definition": "The reason that can be presented to the user as to why this time is not available.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PractitionerRole.notAvailable.during",
"path": "PractitionerRole.notAvailable.during",
"short": "Service not availablefrom this date",
"definition": "Service is not available (seasonally or for a public holiday) from this date.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.availabilityExceptions",
"path": "PractitionerRole.availabilityExceptions",
"short": "Description of availability exceptions",
"definition": "A description of site availability exceptions, e.g. public holiday availability. Succinctly describing all possible exceptions to normal site availability as details in the available Times and not available Times.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.endpoint",
"path": "PractitionerRole.endpoint",
"short": "Technical endpoints providing access to services operated for the practitioner with this role",
"definition": "Technical endpoints providing access to services operated for the practitioner with this role.",
"requirements": "Organizations have multiple systems that provide various services and ,ay also be different for practitioners too.\r\rSo the endpoint satisfies the need to be able to define the technical connection details for how to connect to them, and for what purpose.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Endpoint"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
}
]
},
"differential": {
"element": [
{
"id": "PractitionerRole",
"path": "PractitionerRole",
"short": "Roles/organizations the practitioner is associated with",
"definition": "A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "v2",
"map": "PRD (as one example)"
},
{
"identity": "rim",
"map": "Role"
},
{
"identity": "servd",
"map": "ServiceSiteProvider"
},
{
"identity": "w5",
"map": "administrative.individual"
}
]
},
{
"id": "PractitionerRole.identifier",
"path": "PractitionerRole.identifier",
"short": "Business Identifiers that are specific to a role/location",
"definition": "Business Identifiers that are specific to a role/location.",
"requirements": "Often, specific identities are assigned for the agent.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRD-7 (or XCN.1)"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "servd",
"map": "./Identifiers"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "PractitionerRole.active",
"path": "PractitionerRole.active",
"short": "Whether this practitioner's record is in active use",
"definition": "Whether this practitioner's record is in active use.",
"comment": "Default is true. \r\rIf the practitioner is not in use by one organization, then it should mark the period on the PractitonerRole with an end date (even if they are active) as they may be active in another role.",
"requirements": "Need to be able to mark a practitioner record as not to be used because it was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "STF-7"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "PractitionerRole.period",
"path": "PractitionerRole.period",
"short": "The period during which the practitioner is authorized to perform in these role(s)",
"definition": "The period during which the person is authorized to act as a practitioner in these role(s) for the organization.",
"requirements": "Even after the agencies is revoked, the fact that it existed must still be recorded.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRD-8/9 / PRA-5.4"
},
{
"identity": "rim",
"map": ".performance[@typeCode <= 'PPRF'].ActDefinitionOrEvent.effectiveTime"
},
{
"identity": "servd",
"map": "(ServD maps Practitioners and Organizations via another entity, so this concept is not available)"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "PractitionerRole.practitioner",
"path": "PractitionerRole.practitioner",
"short": "Practitioner that is able to provide the defined services for the organation",
"definition": "Practitioner that is able to provide the defined services for the organation.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player"
}
]
},
{
"id": "PractitionerRole.organization",
"path": "PractitionerRole.organization",
"short": "Organization where the roles are available",
"definition": "The organization where the Practitioner performs the roles associated.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "PractitionerRole.code",
"path": "PractitionerRole.code",
"short": "Roles which this practitioner may perform",
"definition": "Roles which this practitioner is authorized to perform for the organization.",
"comment": "A person may have more than one role. At least one role is required.",
"requirements": "Need to know what authority the practitioner has - what can they do?",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PractitionerRole"
}
],
"strength": "example",
"description": "The role a person plays representing an organization",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/practitioner-role"
}
},
"mapping": [
{
"identity": "v2",
"map": "PRD-1 / STF-18 / PRA-3 / PRT-4 / ROL-3 / ORC-12 / OBR-16 / PV1-7 / PV1-8 / PV1-9 / PV1-17"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "servd",
"map": "(ServD maps Practitioners and Organizations via another entity, so this concept is not available)"
}
]
},
{
"id": "PractitionerRole.specialty",
"path": "PractitionerRole.specialty",
"short": "Specific specialty of the practitioner",
"definition": "Specific specialty of the practitioner.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PractitionerSpecialty"
}
],
"strength": "preferred",
"description": "Specific specialty associated with the agency",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/c80-practice-codes"
}
},
"mapping": [
{
"identity": "v2",
"map": "PRA-5"
},
{
"identity": "rim",
"map": ".player.HealthCareProvider[@classCode = 'PROV'].code"
},
{
"identity": "servd",
"map": "./Specialty"
}
]
},
{
"id": "PractitionerRole.location",
"path": "PractitionerRole.location",
"short": "The location(s) at which this practitioner provides care",
"definition": "The location(s) at which this practitioner provides care.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".performance.ActDefinitionOrEvent.ServiceDeliveryLocation[@classCode = 'SDLOC']"
},
{
"identity": "servd",
"map": "(ServD maps Practitioners and Organizations via another entity, so this concept is not available)
However these are accessed via the Site.ServiceSite.ServiceSiteProvider record. (The Site has the location)"
},
{
"identity": "w5",
"map": "where"
}
]
},
{
"id": "PractitionerRole.healthcareService",
"path": "PractitionerRole.healthcareService",
"short": "The list of healthcare services that this worker provides for this role's Organization/Location(s)",
"definition": "The list of healthcare services that this worker provides for this role's Organization/Location(s).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/HealthcareService"
}
],
"mapping": [
{
"identity": "v2",
"map": "EDU-2 / AFF-3"
},
{
"identity": "rim",
"map": ".player.QualifiedEntity[@classCode = 'QUAL'].code"
}
]
},
{
"id": "PractitionerRole.telecom",
"path": "PractitionerRole.telecom",
"short": "Contact details that are specific to the role/location/service",
"definition": "Contact details that are specific to the role/location/service.",
"requirements": "Often practitioners have a dedicated line for each location (or service) that they work at, and need to be able to define separate contact details for each of these.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".telecom"
}
]
},
{
"id": "PractitionerRole.availableTime",
"path": "PractitionerRole.availableTime",
"short": "Times the Service Site is available",
"definition": "A collection of times that the Service Site is available.",
"comment": "More detailed availability information may be provided in associated Schedule/Slot resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.availableTime.daysOfWeek",
"path": "PractitionerRole.availableTime.daysOfWeek",
"short": "mon | tue | wed | thu | fri | sat | sun",
"definition": "Indicates which days of the week are available between the start and end Times.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "DaysOfWeek"
}
],
"strength": "required",
"description": "The days of the week.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/days-of-week"
}
},
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.availableTime.allDay",
"path": "PractitionerRole.availableTime.allDay",
"short": "Always available? e.g. 24 hour service",
"definition": "Is this always available? (hence times are irrelevant) e.g. 24 hour service.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.availableTime.availableStartTime",
"path": "PractitionerRole.availableTime.availableStartTime",
"short": "Opening time of day (ignored if allDay = true)",
"definition": "The opening time of day. Note: If the AllDay flag is set, then this time is ignored.",
"comment": "The timezone is expected to be for where this HealthcareService is provided at.",
"min": 0,
"max": "1",
"type": [
{
"code": "time"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.availableTime.availableEndTime",
"path": "PractitionerRole.availableTime.availableEndTime",
"short": "Closing time of day (ignored if allDay = true)",
"definition": "The closing time of day. Note: If the AllDay flag is set, then this time is ignored.",
"comment": "The timezone is expected to be for where this HealthcareService is provided at.",
"min": 0,
"max": "1",
"type": [
{
"code": "time"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.notAvailable",
"path": "PractitionerRole.notAvailable",
"short": "Not available during this time due to provided reason",
"definition": "The HealthcareService is not available during this period of time due to the provided reason.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.notAvailable.description",
"path": "PractitionerRole.notAvailable.description",
"short": "Reason presented to the user explaining why time not available",
"definition": "The reason that can be presented to the user as to why this time is not available.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "PractitionerRole.notAvailable.during",
"path": "PractitionerRole.notAvailable.during",
"short": "Service not availablefrom this date",
"definition": "Service is not available (seasonally or for a public holiday) from this date.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.availabilityExceptions",
"path": "PractitionerRole.availabilityExceptions",
"short": "Description of availability exceptions",
"definition": "A description of site availability exceptions, e.g. public holiday availability. Succinctly describing all possible exceptions to normal site availability as details in the available Times and not available Times.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "PractitionerRole.endpoint",
"path": "PractitionerRole.endpoint",
"short": "Technical endpoints providing access to services operated for the practitioner with this role",
"definition": "Technical endpoints providing access to services operated for the practitioner with this role.",
"requirements": "Organizations have multiple systems that provide various services and ,ay also be different for practitioners too.\r\rSo the endpoint satisfies the need to be able to define the technical connection details for how to connect to them, and for what purpose.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Endpoint"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Procedure",
"resource": {
"resourceType": "StructureDefinition",
"id": "Procedure",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Procedure I DomainResource An action that is being or was performed on a patient
+ Reason not done is only permitted if notDone indicator is true
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier External Identifiers for this procedure
definition Σ 0..* Reference(PlanDefinition | ActivityDefinition | HealthcareService) Instantiates protocol or definition
basedOn Σ 0..* Reference(CarePlan | ProcedureRequest | ReferralRequest) A request for this procedure
partOf Σ 0..* Reference(Procedure | Observation | MedicationAdministration) Part of referenced event
status ?!Σ 1..1 code preparation | in-progress | suspended | aborted | completed | entered-in-error | unknown
EventStatus (Required) notDone ?!Σ 0..1 boolean True if procedure was not performed as scheduled notDoneReason ΣI 0..1 CodeableConcept Reason procedure was not performed
Procedure Not Performed Reason (SNOMED-CT) (Example) category Σ 0..1 CodeableConcept Classification of the procedure
Procedure Category Codes (SNOMED CT) (Example) code Σ 0..1 CodeableConcept Identification of the procedure
Procedure Codes (SNOMED CT) (Example) subject Σ 1..1 Reference(Patient | Group) Who the procedure was performed on context Σ 0..1 Reference(Encounter | EpisodeOfCare) Encounter or episode associated with the procedure performed[x] Σ 0..1 Date/Period the procedure was performed performedDateTime dateTime performedPeriod Period performer Σ 0..* BackboneElement The people who performed the procedure
role Σ 0..1 CodeableConcept The role the actor was in
Procedure Performer Role Codes (Example) actor Σ 1..1 Reference(Practitioner | Organization | Patient | RelatedPerson | Device) The reference to the practitioner onBehalfOf 0..1 Reference(Organization) Organization the device or practitioner was acting for location Σ 0..1 Reference(Location) Where the procedure happened reasonCode Σ 0..* CodeableConcept Coded reason procedure performed
Procedure Reason Codes (Example)
reasonReference Σ 0..* Reference(Condition | Observation) Condition that is the reason the procedure performed
bodySite Σ 0..* CodeableConcept Target body sites
SNOMED CT Body Structures (Example)
outcome Σ 0..1 CodeableConcept The result of procedure
Procedure Outcome Codes (SNOMED CT) (Example) report 0..* Reference(DiagnosticReport) Any report resulting from the procedure
complication 0..* CodeableConcept Complication following the procedure
Condition/Problem/Diagnosis Codes (Example)
complicationDetail 0..* Reference(Condition) A condition that is a result of the procedure
followUp 0..* CodeableConcept Instructions for follow up
Procedure Follow up Codes (SNOMED CT) (Example)
note 0..* Annotation Additional information about the procedure
focalDevice 0..* BackboneElement Device changed in procedure
action 0..1 CodeableConcept Kind of change to device
Procedure Device Action Codes (Preferred) manipulated 1..1 Reference(Device) Device that was changed usedReference 0..* Reference(Device | Medication | Substance) Items used during procedure
usedCode 0..* CodeableConcept Coded items used during the procedure
FHIR Device Types (Example)
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "pc"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Procedure",
"name": "Procedure",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Patient Care)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/patientcare/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Procedure Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Procedure",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Procedure",
"path": "Procedure",
"short": "An action that is being or was performed on a patient",
"definition": "An action that is or was performed on a patient. This can be a physical intervention like an operation, or less invasive like counseling or hypnotherapy.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "pro-1",
"severity": "error",
"human": "Reason not done is only permitted if notDone indicator is true",
"expression": "notDoneReason.empty() or notDone = true",
"xpath": "not(exists(f:notDoneReason)) or f:notDone/@value=true()"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "Procedure[moodCode=EVN]"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "Procedure.id",
"path": "Procedure.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Procedure.meta",
"path": "Procedure.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Procedure.implicitRules",
"path": "Procedure.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Procedure.language",
"path": "Procedure.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Procedure.text",
"path": "Procedure.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Procedure.contained",
"path": "Procedure.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Procedure.extension",
"path": "Procedure.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Procedure.modifierExtension",
"path": "Procedure.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Procedure.identifier",
"path": "Procedure.identifier",
"short": "External Identifiers for this procedure",
"definition": "This records identifiers associated with this procedure that are defined by business processes and/or used to refer to it when a direct URL reference to the resource itself is not appropriate (e.g. in CDA documents, or in written / printed documentation).",
"requirements": "Need to allow connection to a wider workflow.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "Some combination of ORC-2 / ORC-3 / OBR-2 / OBR-3 / IPC-1 / IPC-2 / IPC-3 / IPC-4"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Procedure.definition",
"path": "Procedure.definition",
"short": "Instantiates protocol or definition",
"definition": "A protocol, guideline, orderset or other definition that was adhered to in whole or in part by this procedure.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/HealthcareService"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target"
}
]
},
{
"id": "Procedure.basedOn",
"path": "Procedure.basedOn",
"short": "A request for this procedure",
"definition": "A reference to a resource that contains details of the request for this procedure.",
"alias": [
"fulfills"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target[classCode=(various e.g. PROC, OBS, PCPR, ACT, moodCode=RQO].code"
}
]
},
{
"id": "Procedure.partOf",
"path": "Procedure.partOf",
"short": "Part of referenced event",
"definition": "A larger event of which this particular procedure is a component or step.",
"comment": "The MedicationAdministration has a partOf reference to Procedure, but this is not a circular reference. For a surgical procedure, the anesthesia related medicationAdministration is part of the procedure. For an IV medication administration, the procedure to insert the IV port is part of the medication administration.",
"alias": [
"container"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Procedure"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationAdministration"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=SBADM or PROC or OBS, moodCode=EVN]"
}
]
},
{
"id": "Procedure.status",
"path": "Procedure.status",
"short": "preparation | in-progress | suspended | aborted | completed | entered-in-error | unknown",
"definition": "A code specifying the state of the procedure. Generally this will be in-progress or completed state.",
"comment": "The unknown code is not to be used to convey other statuses. The unknown code should be used when one of the statuses applies, but the authoring system doesn't know the current state of the procedure.\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the procedure.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/event-status"
}
},
"mapping": [
{
"identity": "rim",
"map": "statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Procedure.notDone",
"path": "Procedure.notDone",
"short": "True if procedure was not performed as scheduled",
"definition": "Set this to true if the record is saying that the procedure was NOT performed.",
"comment": "If true, it means the procedure did not occur as described. Typically it would be accompanied by attributes describing the type of activity. It might also be accompanied by body site information or time information (i.e. no procedure was done to the left arm or no procedure was done in this 2-year period). Specifying additional information such as performer, outcome, etc. is generally inappropriate. For example, it's not that useful to say \"There was no appendectomy done at 12:03pm June 6th by Dr. Smith with a successful outcome\" as it implies that there *could* have been an appendectomy done at any other time, by any other clinician or with any other outcome.\n\nThis element is labeled as a modifier because it indicates that a procedure didn't happen.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "Procedure.notDoneReason",
"path": "Procedure.notDoneReason",
"short": "Reason procedure was not performed",
"definition": "A code indicating why the procedure was not performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"pro-1"
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureNegationReason"
}
],
"strength": "example",
"description": "A code that identifies the reason a procedure was not performed.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-not-performed-reason"
}
},
"mapping": [
{
"identity": "rim",
"map": ".reason.Observation.value"
}
]
},
{
"id": "Procedure.category",
"path": "Procedure.category",
"short": "Classification of the procedure",
"definition": "A code that classifies the procedure for searching, sorting and display purposes (e.g. \"Surgical Procedure\").",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureCategory"
}
],
"strength": "example",
"description": "A code that classifies a procedure for searching, sorting and display purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"LIST\", moodCode=\"EVN\"].code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Procedure.code",
"path": "Procedure.code",
"short": "Identification of the procedure",
"definition": "The specific procedure that is performed. Use text if the exact nature of the procedure cannot be coded (e.g. \"Laparoscopic Appendectomy\").",
"requirements": "0..1 to account for primarily narrative only resources.",
"alias": [
"type"
],
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureCode"
}
],
"strength": "example",
"description": "A code to identify a specific procedure .",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-code"
}
},
"mapping": [
{
"identity": "v2",
"map": "OBR-44/OBR-45"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Procedure.subject",
"path": "Procedure.subject",
"short": "Who the procedure was performed on",
"definition": "The person, animal or group on which the procedure was performed.",
"alias": [
"patient"
],
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Procedure.context",
"path": "Procedure.context",
"short": "Encounter or episode associated with the procedure",
"definition": "The encounter during which the procedure was performed.",
"alias": [
"encounter"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PV1-19"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "Procedure.performed[x]",
"path": "Procedure.performed[x]",
"short": "Date/Period the procedure was performed",
"definition": "The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "OBR-7"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Procedure.performer",
"path": "Procedure.performer",
"short": "The people who performed the procedure",
"definition": "Limited to 'real' people rather than equipment.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=PRF]"
}
]
},
{
"id": "Procedure.performer.id",
"path": "Procedure.performer.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Procedure.performer.extension",
"path": "Procedure.performer.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Procedure.performer.modifierExtension",
"path": "Procedure.performer.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Procedure.performer.role",
"path": "Procedure.performer.role",
"short": "The role the actor was in",
"definition": "For example: surgeon, anaethetist, endoscopist.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedurePerformerRole"
}
],
"strength": "example",
"description": "A code that identifies the role of a performer of the procedure.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/performer-role"
}
},
"mapping": [
{
"identity": "v2",
"map": "Some combination of STF-18 / PRA-3 / PRT-4 / ROL-3 / ORC-12 / OBR-16 / PV1-7 / PV1-8 / PV1-9 / PV1-17 / OBX-25"
},
{
"identity": "rim",
"map": ".functionCode"
}
]
},
{
"id": "Procedure.performer.actor",
"path": "Procedure.performer.actor",
"short": "The reference to the practitioner",
"definition": "The practitioner who was involved in the procedure.",
"requirements": "A reference to Device supports use cases, such as pacemakers.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ORC-19/PRT-5"
},
{
"identity": "rim",
"map": ".role"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Procedure.performer.onBehalfOf",
"path": "Procedure.performer.onBehalfOf",
"short": "Organization the device or practitioner was acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when performing the action.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "Procedure.location",
"path": "Procedure.location",
"short": "Where the procedure happened",
"definition": "The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.",
"requirements": "Ties a procedure to where the records are likely kept.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=LOC].role[classCode=SDLOC]"
},
{
"identity": "w5",
"map": "where"
}
]
},
{
"id": "Procedure.reasonCode",
"path": "Procedure.reasonCode",
"short": "Coded reason procedure performed",
"definition": "The coded reason why the procedure was performed. This may be coded entity of some type, or may simply be present as text.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureReason"
}
],
"strength": "example",
"description": "A code that identifies the reason a procedure is required.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-reason"
}
},
"mapping": [
{
"identity": "rim",
"map": ".reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Procedure.reasonReference",
"path": "Procedure.reasonReference",
"short": "Condition that is the reason the procedure performed",
"definition": "The condition that is the reason why the procedure was performed.",
"comment": "e.g. endoscopy for dilatation and biopsy, combination diagnosis and therapeutic.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Procedure.bodySite",
"path": "Procedure.bodySite",
"short": "Target body sites",
"definition": "Detailed and structured anatomical location information. Multiple locations are allowed - e.g. multiple punch biopsies of a lesion.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "BodySite"
}
],
"strength": "example",
"description": "Codes describing anatomical locations. May include laterality.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/body-site"
}
},
"mapping": [
{
"identity": "v2",
"map": "OBX-20"
},
{
"identity": "rim",
"map": ".targetSiteCode"
}
]
},
{
"id": "Procedure.outcome",
"path": "Procedure.outcome",
"short": "The result of procedure",
"definition": "The outcome of the procedure - did it resolve reasons for the procedure being performed?",
"comment": "If outcome contains narrative text only, it can be captured using the CodeableConcept.text.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureOutcome"
}
],
"strength": "example",
"description": "An outcome of a procedure - whether it was resolved or otherwise.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-outcome"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=OUT].target.text"
}
]
},
{
"id": "Procedure.report",
"path": "Procedure.report",
"short": "Any report resulting from the procedure",
"definition": "This could be a histology result, pathology report, surgical report, etc..",
"comment": "There could potentially be multiple reports - e.g. if this was a procedure which took multiple biopsies resulting in a number of anatomical pathology reports.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DiagnosticReport"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "Procedure.complication",
"path": "Procedure.complication",
"short": "Complication following the procedure",
"definition": "Any complications that occurred during the procedure, or in the immediate post-performance period. These are generally tracked separately from the notes, which will typically describe the procedure itself rather than any 'post procedure' issues.",
"comment": "If complications are only expressed by the narrative text, they can be captured using the CodeableConcept.text.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureComplication"
}
],
"strength": "example",
"description": "Codes describing complications that resulted from a procedure.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/condition-code"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=OUTC].target[classCode=OBS, code=\"complication\", moodCode=EVN].value"
}
]
},
{
"id": "Procedure.complicationDetail",
"path": "Procedure.complicationDetail",
"short": "A condition that is a result of the procedure",
"definition": "Any complications that occurred during the procedure, or in the immediate post-performance period.",
"requirements": "This is used to document a condition that is a result of the procedure, not the condition that was the reason for the procedure.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=OUTC].target[classCode=OBS, code=\"complication\", moodCode=EVN].value"
}
]
},
{
"id": "Procedure.followUp",
"path": "Procedure.followUp",
"short": "Instructions for follow up",
"definition": "If the procedure required specific follow up - e.g. removal of sutures. The followup may be represented as a simple note, or could potentially be more complex in which case the CarePlan resource can be used.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureFollowUp"
}
],
"strength": "example",
"description": "Specific follow up required for a procedure e.g. removal of sutures.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-followup"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=ACT, moodCode=INT].code"
}
]
},
{
"id": "Procedure.note",
"path": "Procedure.note",
"short": "Additional information about the procedure",
"definition": "Any other notes about the procedure. E.g. the operative notes.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "v2",
"map": "NTE"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"annotation\"].value"
}
]
},
{
"id": "Procedure.focalDevice",
"path": "Procedure.focalDevice",
"short": "Device changed in procedure",
"definition": "A device that is implanted, removed or otherwise manipulated (calibration, battery replacement, fitting a prosthesis, attaching a wound-vac, etc.) as a focal portion of the Procedure.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=DEV].role[classCode=MANU]"
}
]
},
{
"id": "Procedure.focalDevice.id",
"path": "Procedure.focalDevice.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Procedure.focalDevice.extension",
"path": "Procedure.focalDevice.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Procedure.focalDevice.modifierExtension",
"path": "Procedure.focalDevice.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Procedure.focalDevice.action",
"path": "Procedure.focalDevice.action",
"short": "Kind of change to device",
"definition": "The kind of change that happened to the device during the procedure.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "DeviceActionKind"
}
],
"strength": "preferred",
"description": "A kind of change that happened to the device during the procedure.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/device-action"
}
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"procedure device action\"].value=:procedure device action codes"
}
]
},
{
"id": "Procedure.focalDevice.manipulated",
"path": "Procedure.focalDevice.manipulated",
"short": "Device that was changed",
"definition": "The device that was manipulated (changed) during the procedure.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=DEV].role[classCode=SDLOC]"
}
]
},
{
"id": "Procedure.usedReference",
"path": "Procedure.usedReference",
"short": "Items used during procedure",
"definition": "Identifies medications, devices and any other substance used as part of the procedure.",
"comment": "For devices actually implanted or removed, use Procedure.device.",
"requirements": "Used for tracking contamination, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=DEV].role[classCode=MANU] or\n.participation[typeCode=CSM].role[classCode=ADMM] (for Medication or Substance)"
}
]
},
{
"id": "Procedure.usedCode",
"path": "Procedure.usedCode",
"short": "Coded items used during the procedure",
"definition": "Identifies coded items that were used as part of the procedure.",
"comment": "For devices actually implanted or removed, use Procedure.device.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureUsed"
}
],
"strength": "example",
"description": "Codes describing items used during a procedure",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/device-kind"
}
},
"mapping": [
{
"identity": "rim",
"map": "participation[typeCode=Dev].role[classCode=MANU]"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Procedure",
"path": "Procedure",
"short": "An action that is being or was performed on a patient",
"definition": "An action that is or was performed on a patient. This can be a physical intervention like an operation, or less invasive like counseling or hypnotherapy.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "pro-1",
"severity": "error",
"human": "Reason not done is only permitted if notDone indicator is true",
"expression": "notDoneReason.empty() or notDone = true",
"xpath": "not(exists(f:notDoneReason)) or f:notDone/@value=true()"
}
],
"mapping": [
{
"identity": "rim",
"map": "Procedure[moodCode=EVN]"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "Procedure.identifier",
"path": "Procedure.identifier",
"short": "External Identifiers for this procedure",
"definition": "This records identifiers associated with this procedure that are defined by business processes and/or used to refer to it when a direct URL reference to the resource itself is not appropriate (e.g. in CDA documents, or in written / printed documentation).",
"requirements": "Need to allow connection to a wider workflow.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "Some combination of ORC-2 / ORC-3 / OBR-2 / OBR-3 / IPC-1 / IPC-2 / IPC-3 / IPC-4"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Procedure.definition",
"path": "Procedure.definition",
"short": "Instantiates protocol or definition",
"definition": "A protocol, guideline, orderset or other definition that was adhered to in whole or in part by this procedure.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/HealthcareService"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target"
}
]
},
{
"id": "Procedure.basedOn",
"path": "Procedure.basedOn",
"short": "A request for this procedure",
"definition": "A reference to a resource that contains details of the request for this procedure.",
"alias": [
"fulfills"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target[classCode=(various e.g. PROC, OBS, PCPR, ACT, moodCode=RQO].code"
}
]
},
{
"id": "Procedure.partOf",
"path": "Procedure.partOf",
"short": "Part of referenced event",
"definition": "A larger event of which this particular procedure is a component or step.",
"comment": "The MedicationAdministration has a partOf reference to Procedure, but this is not a circular reference. For a surgical procedure, the anesthesia related medicationAdministration is part of the procedure. For an IV medication administration, the procedure to insert the IV port is part of the medication administration.",
"alias": [
"container"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Procedure"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/MedicationAdministration"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=SBADM or PROC or OBS, moodCode=EVN]"
}
]
},
{
"id": "Procedure.status",
"path": "Procedure.status",
"short": "preparation | in-progress | suspended | aborted | completed | entered-in-error | unknown",
"definition": "A code specifying the state of the procedure. Generally this will be in-progress or completed state.",
"comment": "The unknown code is not to be used to convey other statuses. The unknown code should be used when one of the statuses applies, but the authoring system doesn't know the current state of the procedure.\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the procedure.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/event-status"
}
},
"mapping": [
{
"identity": "rim",
"map": "statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Procedure.notDone",
"path": "Procedure.notDone",
"short": "True if procedure was not performed as scheduled",
"definition": "Set this to true if the record is saying that the procedure was NOT performed.",
"comment": "If true, it means the procedure did not occur as described. Typically it would be accompanied by attributes describing the type of activity. It might also be accompanied by body site information or time information (i.e. no procedure was done to the left arm or no procedure was done in this 2-year period). Specifying additional information such as performer, outcome, etc. is generally inappropriate. For example, it's not that useful to say \"There was no appendectomy done at 12:03pm June 6th by Dr. Smith with a successful outcome\" as it implies that there *could* have been an appendectomy done at any other time, by any other clinician or with any other outcome.\n\nThis element is labeled as a modifier because it indicates that a procedure didn't happen.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "Procedure.notDoneReason",
"path": "Procedure.notDoneReason",
"short": "Reason procedure was not performed",
"definition": "A code indicating why the procedure was not performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"pro-1"
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureNegationReason"
}
],
"strength": "example",
"description": "A code that identifies the reason a procedure was not performed.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-not-performed-reason"
}
},
"mapping": [
{
"identity": "rim",
"map": ".reason.Observation.value"
}
]
},
{
"id": "Procedure.category",
"path": "Procedure.category",
"short": "Classification of the procedure",
"definition": "A code that classifies the procedure for searching, sorting and display purposes (e.g. \"Surgical Procedure\").",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureCategory"
}
],
"strength": "example",
"description": "A code that classifies a procedure for searching, sorting and display purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"LIST\", moodCode=\"EVN\"].code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Procedure.code",
"path": "Procedure.code",
"short": "Identification of the procedure",
"definition": "The specific procedure that is performed. Use text if the exact nature of the procedure cannot be coded (e.g. \"Laparoscopic Appendectomy\").",
"requirements": "0..1 to account for primarily narrative only resources.",
"alias": [
"type"
],
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureCode"
}
],
"strength": "example",
"description": "A code to identify a specific procedure .",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-code"
}
},
"mapping": [
{
"identity": "v2",
"map": "OBR-44/OBR-45"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Procedure.subject",
"path": "Procedure.subject",
"short": "Who the procedure was performed on",
"definition": "The person, animal or group on which the procedure was performed.",
"alias": [
"patient"
],
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Procedure.context",
"path": "Procedure.context",
"short": "Encounter or episode associated with the procedure",
"definition": "The encounter during which the procedure was performed.",
"alias": [
"encounter"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PV1-19"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "Procedure.performed[x]",
"path": "Procedure.performed[x]",
"short": "Date/Period the procedure was performed",
"definition": "The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "OBR-7"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Procedure.performer",
"path": "Procedure.performer",
"short": "The people who performed the procedure",
"definition": "Limited to 'real' people rather than equipment.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=PRF]"
}
]
},
{
"id": "Procedure.performer.role",
"path": "Procedure.performer.role",
"short": "The role the actor was in",
"definition": "For example: surgeon, anaethetist, endoscopist.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedurePerformerRole"
}
],
"strength": "example",
"description": "A code that identifies the role of a performer of the procedure.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/performer-role"
}
},
"mapping": [
{
"identity": "v2",
"map": "Some combination of STF-18 / PRA-3 / PRT-4 / ROL-3 / ORC-12 / OBR-16 / PV1-7 / PV1-8 / PV1-9 / PV1-17 / OBX-25"
},
{
"identity": "rim",
"map": ".functionCode"
}
]
},
{
"id": "Procedure.performer.actor",
"path": "Procedure.performer.actor",
"short": "The reference to the practitioner",
"definition": "The practitioner who was involved in the procedure.",
"requirements": "A reference to Device supports use cases, such as pacemakers.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ORC-19/PRT-5"
},
{
"identity": "rim",
"map": ".role"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Procedure.performer.onBehalfOf",
"path": "Procedure.performer.onBehalfOf",
"short": "Organization the device or practitioner was acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when performing the action.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "Procedure.location",
"path": "Procedure.location",
"short": "Where the procedure happened",
"definition": "The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.",
"requirements": "Ties a procedure to where the records are likely kept.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=LOC].role[classCode=SDLOC]"
},
{
"identity": "w5",
"map": "where"
}
]
},
{
"id": "Procedure.reasonCode",
"path": "Procedure.reasonCode",
"short": "Coded reason procedure performed",
"definition": "The coded reason why the procedure was performed. This may be coded entity of some type, or may simply be present as text.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureReason"
}
],
"strength": "example",
"description": "A code that identifies the reason a procedure is required.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-reason"
}
},
"mapping": [
{
"identity": "rim",
"map": ".reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Procedure.reasonReference",
"path": "Procedure.reasonReference",
"short": "Condition that is the reason the procedure performed",
"definition": "The condition that is the reason why the procedure was performed.",
"comment": "e.g. endoscopy for dilatation and biopsy, combination diagnosis and therapeutic.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Procedure.bodySite",
"path": "Procedure.bodySite",
"short": "Target body sites",
"definition": "Detailed and structured anatomical location information. Multiple locations are allowed - e.g. multiple punch biopsies of a lesion.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "BodySite"
}
],
"strength": "example",
"description": "Codes describing anatomical locations. May include laterality.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/body-site"
}
},
"mapping": [
{
"identity": "v2",
"map": "OBX-20"
},
{
"identity": "rim",
"map": ".targetSiteCode"
}
]
},
{
"id": "Procedure.outcome",
"path": "Procedure.outcome",
"short": "The result of procedure",
"definition": "The outcome of the procedure - did it resolve reasons for the procedure being performed?",
"comment": "If outcome contains narrative text only, it can be captured using the CodeableConcept.text.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureOutcome"
}
],
"strength": "example",
"description": "An outcome of a procedure - whether it was resolved or otherwise.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-outcome"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=OUT].target.text"
}
]
},
{
"id": "Procedure.report",
"path": "Procedure.report",
"short": "Any report resulting from the procedure",
"definition": "This could be a histology result, pathology report, surgical report, etc..",
"comment": "There could potentially be multiple reports - e.g. if this was a procedure which took multiple biopsies resulting in a number of anatomical pathology reports.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/DiagnosticReport"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "Procedure.complication",
"path": "Procedure.complication",
"short": "Complication following the procedure",
"definition": "Any complications that occurred during the procedure, or in the immediate post-performance period. These are generally tracked separately from the notes, which will typically describe the procedure itself rather than any 'post procedure' issues.",
"comment": "If complications are only expressed by the narrative text, they can be captured using the CodeableConcept.text.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureComplication"
}
],
"strength": "example",
"description": "Codes describing complications that resulted from a procedure.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/condition-code"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=OUTC].target[classCode=OBS, code=\"complication\", moodCode=EVN].value"
}
]
},
{
"id": "Procedure.complicationDetail",
"path": "Procedure.complicationDetail",
"short": "A condition that is a result of the procedure",
"definition": "Any complications that occurred during the procedure, or in the immediate post-performance period.",
"requirements": "This is used to document a condition that is a result of the procedure, not the condition that was the reason for the procedure.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=OUTC].target[classCode=OBS, code=\"complication\", moodCode=EVN].value"
}
]
},
{
"id": "Procedure.followUp",
"path": "Procedure.followUp",
"short": "Instructions for follow up",
"definition": "If the procedure required specific follow up - e.g. removal of sutures. The followup may be represented as a simple note, or could potentially be more complex in which case the CarePlan resource can be used.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureFollowUp"
}
],
"strength": "example",
"description": "Specific follow up required for a procedure e.g. removal of sutures.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-followup"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=ACT, moodCode=INT].code"
}
]
},
{
"id": "Procedure.note",
"path": "Procedure.note",
"short": "Additional information about the procedure",
"definition": "Any other notes about the procedure. E.g. the operative notes.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "v2",
"map": "NTE"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"annotation\"].value"
}
]
},
{
"id": "Procedure.focalDevice",
"path": "Procedure.focalDevice",
"short": "Device changed in procedure",
"definition": "A device that is implanted, removed or otherwise manipulated (calibration, battery replacement, fitting a prosthesis, attaching a wound-vac, etc.) as a focal portion of the Procedure.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=DEV].role[classCode=MANU]"
}
]
},
{
"id": "Procedure.focalDevice.action",
"path": "Procedure.focalDevice.action",
"short": "Kind of change to device",
"definition": "The kind of change that happened to the device during the procedure.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "DeviceActionKind"
}
],
"strength": "preferred",
"description": "A kind of change that happened to the device during the procedure.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/device-action"
}
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"procedure device action\"].value=:procedure device action codes"
}
]
},
{
"id": "Procedure.focalDevice.manipulated",
"path": "Procedure.focalDevice.manipulated",
"short": "Device that was changed",
"definition": "The device that was manipulated (changed) during the procedure.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=DEV].role[classCode=SDLOC]"
}
]
},
{
"id": "Procedure.usedReference",
"path": "Procedure.usedReference",
"short": "Items used during procedure",
"definition": "Identifies medications, devices and any other substance used as part of the procedure.",
"comment": "For devices actually implanted or removed, use Procedure.device.",
"requirements": "Used for tracking contamination, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=DEV].role[classCode=MANU] or\n.participation[typeCode=CSM].role[classCode=ADMM] (for Medication or Substance)"
}
]
},
{
"id": "Procedure.usedCode",
"path": "Procedure.usedCode",
"short": "Coded items used during the procedure",
"definition": "Identifies coded items that were used as part of the procedure.",
"comment": "For devices actually implanted or removed, use Procedure.device.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureUsed"
}
],
"strength": "example",
"description": "Codes describing items used during a procedure",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/device-kind"
}
},
"mapping": [
{
"identity": "rim",
"map": "participation[typeCode=Dev].role[classCode=MANU]"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest",
"resource": {
"resourceType": "StructureDefinition",
"id": "ProcedureRequest",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints ProcedureRequest DomainResource A request for a procedure or diagnostic to be performed
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier Identifiers assigned to this order
definition Σ 0..* Reference(ActivityDefinition | PlanDefinition) Protocol or definition
basedOn Σ 0..* Reference(Any) What request fulfills
replaces Σ 0..* Reference(Any) What request replaces
requisition Σ 0..1 Identifier Composite Request ID status ?!Σ 1..1 code draft | active | suspended | completed | entered-in-error | cancelled
RequestStatus (Required) intent ?!Σ 1..1 code proposal | plan | order +
RequestIntent (Required) priority Σ 0..1 code routine | urgent | asap | stat
RequestPriority (Required) doNotPerform ?!Σ 0..1 boolean True if procedure should not be performed category Σ 0..* CodeableConcept Classification of procedure
Procedure Category Codes (SNOMED CT) (Example)
code Σ 1..1 CodeableConcept What is being requested/ordered
Procedure Codes (SNOMED CT) (Example) subject Σ 1..1 Reference(Patient | Group | Location | Device) Individual the service is ordered for context Σ 0..1 Reference(Encounter | EpisodeOfCare) Encounter or Episode during which request was created occurrence[x] Σ 0..1 When procedure should occur occurrenceDateTime dateTime occurrencePeriod Period occurrenceTiming Timing asNeeded[x] Σ 0..1 Preconditions for procedure or diagnostic
SNOMED CT Medication As Needed Reason Codes (Example) asNeededBoolean boolean asNeededCodeableConcept CodeableConcept authoredOn Σ 0..1 dateTime Date request signed requester Σ 0..1 BackboneElement Who/what is requesting procedure or diagnostic agent Σ 1..1 Reference(Device | Practitioner | Organization) Individual making the request onBehalfOf Σ 0..1 Reference(Organization) Organization agent is acting for performerType Σ 0..1 CodeableConcept Performer role
Participant Roles (Example) performer Σ 0..1 Reference(Practitioner | Organization | Patient | Device | RelatedPerson | HealthcareService) Requested perfomer reasonCode Σ 0..* CodeableConcept Explanation/Justification for test
Procedure Reason Codes (Example)
reasonReference Σ 0..* Reference(Condition | Observation) Explanation/Justification for test
supportingInfo 0..* Reference(Any) Additional clinical information
specimen Σ 0..* Reference(Specimen) Procedure Samples
bodySite Σ 0..* CodeableConcept Location on Body
SNOMED CT Body Structures (Example)
note 0..* Annotation Comments
relevantHistory 0..* Reference(Provenance) Request provenance
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "oo"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest",
"name": "ProcedureRequest",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Orders and Observations)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/orders/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for ProcedureRequest Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "quick",
"uri": "http://wiki.siframework.org/CQF",
"name": "Quality Improvement and Clinical Knowledge (QUICK)"
}
],
"kind": "resource",
"abstract": false,
"type": "ProcedureRequest",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "ProcedureRequest",
"path": "ProcedureRequest",
"short": "A request for a procedure or diagnostic to be performed",
"definition": "A record of a request for diagnostic investigations, treatments, or operations to be performed.",
"alias": [
"diagnostic request"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "v2",
"map": "ORC"
},
{
"identity": "rim",
"map": "Act[moodCode<=INT]"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "ProcedureRequest.id",
"path": "ProcedureRequest.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "ProcedureRequest.meta",
"path": "ProcedureRequest.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "ProcedureRequest.implicitRules",
"path": "ProcedureRequest.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "ProcedureRequest.language",
"path": "ProcedureRequest.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "ProcedureRequest.text",
"path": "ProcedureRequest.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "ProcedureRequest.contained",
"path": "ProcedureRequest.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcedureRequest.extension",
"path": "ProcedureRequest.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcedureRequest.modifierExtension",
"path": "ProcedureRequest.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcedureRequest.identifier",
"path": "ProcedureRequest.identifier",
"short": "Identifiers assigned to this order",
"definition": "Identifiers assigned to this order instance by the orderer and/or the receiver and/or order fulfiller.",
"comment": "The identifier.type element is used to distinguish between the identifiers assigned by the orderer (known as the 'Placer' in HL7 v2) and the producer of the observations in response to the order (known as the 'Filler' in HL7 v2). For further discussion and examples see the resource notes section below.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "v2",
"map": "ORC.2, ORC.3"
},
{
"identity": "rim",
"map": ".identifier"
},
{
"identity": "quick",
"map": "ClinicalStatement.identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ProcedureRequest.definition",
"path": "ProcedureRequest.definition",
"short": "Protocol or definition",
"definition": "Protocol or definition followed by this request.",
"alias": [
"protocol"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.definition"
},
{
"identity": "v2",
"map": "Varies by domain"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target"
}
]
},
{
"id": "ProcedureRequest.basedOn",
"path": "ProcedureRequest.basedOn",
"short": "What request fulfills",
"definition": "Plan/proposal/order fulfilled by this request.",
"alias": [
"fulfills"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.basedOn"
},
{
"identity": "v2",
"map": "ORC.8 (plus others)"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target"
}
]
},
{
"id": "ProcedureRequest.replaces",
"path": "ProcedureRequest.replaces",
"short": "What request replaces",
"definition": "The request takes the place of the referenced completed or terminated request(s).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.replaces"
},
{
"identity": "v2",
"map": "Handled by message location of ORC (ORC.1=RO or RU)"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RPLC].target"
}
]
},
{
"id": "ProcedureRequest.requisition",
"path": "ProcedureRequest.requisition",
"short": "Composite Request ID",
"definition": "A shared identifier common to all procedure or diagnostic requests that were authorized more or less simultaneously by a single author, representing the composite or group identifier.",
"comment": "Requests are linked either by a \"basedOn\" relationship (i.e. one request is fulfilling another) or by having a common requisition. Requests that are part of the same requisition are generally treated independently from the perspective of changing their state or maintaining them after initial creation.",
"requirements": "Some business processes need to know if multiple items were ordered as part of the same \"requisition\" for billing or other purposes.",
"alias": [
"grouperId",
"groupIdentifier"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ORC.4"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=COMP].source[moodCode=INT].identifier"
}
]
},
{
"id": "ProcedureRequest.status",
"path": "ProcedureRequest.status",
"short": "draft | active | suspended | completed | entered-in-error | cancelled",
"definition": "The status of the order.",
"comment": "The status is generally fully in the control of the requester - they determine whether the order is draft or active and, after it has been activated, competed, cancelled or suspended. States relating to the activities of the performer are reflected on either the corresponding event (see [Event Pattern](event.html) for general discussion) or using the [Task](task.html) resource.\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestStatus"
}
],
"strength": "required",
"description": "The status of a procedure or diagnostic order.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "v2",
"map": "ORC.5"
},
{
"identity": "rim",
"map": ".status"
},
{
"identity": "quick",
"map": "Action.currentStatus"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ProcedureRequest.intent",
"path": "ProcedureRequest.intent",
"short": "proposal | plan | order +",
"definition": "Whether the request is a proposal, plan, an original order or a reflex order.",
"comment": "This element is labeled as a modifier because the intent alters when and how the resource is actually applicable.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestIntent"
}
],
"strength": "required",
"description": "The kind of procedure or diagnostic request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-intent"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.intent"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".moodCode (nuances beyond PRP/PLAN/RQO would need to be elsewhere)"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ProcedureRequest.priority",
"path": "ProcedureRequest.priority",
"short": "routine | urgent | asap | stat",
"definition": "Indicates how quickly the ProcedureRequest should be addressed with respect to other requests.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "If missing, this task should be performed with normal priority",
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestPriority"
}
],
"strength": "required",
"description": "Identifies the level of importance to be assigned to actioning the request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-priority"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.priority"
},
{
"identity": "v2",
"map": "TQ1.9"
},
{
"identity": "rim",
"map": ".priorityCode"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ProcedureRequest.doNotPerform",
"path": "ProcedureRequest.doNotPerform",
"short": "True if procedure should not be performed",
"definition": "Set this to true if the record is saying that the procedure should NOT be performed.",
"comment": "This element is labeled as a [modifier](conformance-rules.html#isModifier.html) because it indicates that a procedure shouldn't happen, instead of a request for it to happen. In general, only the code and timeframe will be present, though occasional additional qualifiers such as body site or even performer could be included to narrow the scope of the prohibition. If the ProcedureRequest.code and ProcedureRequest.doNotPerform both contain negation, that will reinforce prohibition and should not have a double negative interpretation.",
"requirements": "Used for do not ambulate, do not elevate head of bed, do not flush NG tube, do not take blood pressure on a certain arm, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "ProcedureRequest.category",
"path": "ProcedureRequest.category",
"short": "Classification of procedure",
"definition": "A code that classifies the procedure for searching, sorting and display purposes (e.g. \"Surgical Procedure\").",
"comment": "There may be multiple axis of categorization depending on the context or use case for retrieving or displaying the resource. The level of granularity is defined by the category concepts in the value set.",
"requirements": "Used for filtering what procedure request are retrieved and displayed.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestCategory"
}
],
"strength": "example",
"description": "Classification of the procedure",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"LIST\", moodCode=\"INT\"].code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ProcedureRequest.code",
"path": "ProcedureRequest.code",
"short": "What is being requested/ordered",
"definition": "A code that identifies a particular procedure, diagnostic investigation, or panel of investigations, that have been requested.",
"comment": "Many laboratory and radiology procedure codes embed the specimen/organ system in the test ordeer name, for example, serum or serum/plasma glucose, or a chest xray. The specimen may not be recorded separately from the test code.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestCode"
}
],
"strength": "example",
"description": "Codes for tests/services that can be performed by procedure or diagnostic services. For laboratory, LOINC is (preferred)[http://build.fhir.org/terminologies.html#preferred] and a valueset using LOINC Order codes is available [here](valueset-diagnostic-requests.html).",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-code"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.code"
},
{
"identity": "v2",
"map": "Varies by domain"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "quick",
"map": "Procedure.procedureCode"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "ProcedureRequest.subject",
"path": "ProcedureRequest.subject",
"short": "Individual the service is ordered for",
"definition": "On whom or what the procedure or diagnostic is to be performed. This is usually a human patient, but can also be requested on animals, groups of humans or animals, devices such as dialysis machines, or even locations (typically for environmental scans).",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.subject"
},
{
"identity": "v2",
"map": "Accompanying PID segment"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
},
{
"identity": "quick",
"map": "ClinicalStatement.subject"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "ProcedureRequest.context",
"path": "ProcedureRequest.context",
"short": "Encounter or Episode during which request was created",
"definition": "An encounter or episode of care that provides additional information about the healthcare context in which this request is made.",
"alias": [
"encounter"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.context"
},
{
"identity": "v2",
"map": "Accompanying PV1"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=COMP].source[classCode<=PCPR, moodCode=EVN]"
},
{
"identity": "quick",
"map": "ClinicalStatement.encounter"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "ProcedureRequest.occurrence[x]",
"path": "ProcedureRequest.occurrence[x]",
"short": "When procedure should occur",
"definition": "The date/time at which the diagnostic testing should occur.",
"alias": [
"schedule"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
},
{
"code": "Timing"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.occurrence[x]"
},
{
"identity": "v2",
"map": "Accompanying TQ1/TQ2 segments"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "quick",
"map": "Procedure.procedureSchedule"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "ProcedureRequest.asNeeded[x]",
"path": "ProcedureRequest.asNeeded[x]",
"short": "Preconditions for procedure or diagnostic",
"definition": "If a CodeableConcept is present, it indicates the pre-condition for performing the procedure. For example \"pain\", \"on flare-up\", etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureAsNeededReason"
}
],
"strength": "example",
"description": "A coded concept identifying the pre-condition that should hold prior to performing a procedure. For example \"pain\", \"on flare-up\", etc.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-as-needed-reason"
}
},
"mapping": [
{
"identity": "rim",
"map": "boolean: precondition.negationInd (inversed - so negationInd = true means asNeeded=false CodeableConcept: precondition.observationEventCriterion[code=\"Assertion\"].value"
},
{
"identity": "quick",
"map": "Proposal.prnReason.reason"
}
]
},
{
"id": "ProcedureRequest.authoredOn",
"path": "ProcedureRequest.authoredOn",
"short": "Date request signed",
"definition": "When the request transitioned to being actionable.",
"alias": [
"orderedOn"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "v2",
"map": "ORC.9"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "quick",
"map": "Proposal.proposedAtTime"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ProcedureRequest.requester",
"path": "ProcedureRequest.requester",
"short": "Who/what is requesting procedure or diagnostic",
"definition": "The individual who initiated the request and has responsibility for its activation.",
"comment": "This not the dispatcher, but rather who is the authorizer.",
"alias": [
"author",
"orderer"
],
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester"
},
{
"identity": "v2",
"map": "ORC.12"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "quick",
"map": "ClinicalStatement.statementAuthor"
}
]
},
{
"id": "ProcedureRequest.requester.id",
"path": "ProcedureRequest.requester.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ProcedureRequest.requester.extension",
"path": "ProcedureRequest.requester.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ProcedureRequest.requester.modifierExtension",
"path": "ProcedureRequest.requester.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcedureRequest.requester.agent",
"path": "ProcedureRequest.requester.agent",
"short": "Individual making the request",
"definition": "The device, practitioner or organization who initiated the request.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.agent"
},
{
"identity": "v2",
"map": "ORC.12"
},
{
"identity": "rim",
"map": ".player"
},
{
"identity": "quick",
"map": "ClinicalStatement.statementAuthor"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "ProcedureRequest.requester.onBehalfOf",
"path": "ProcedureRequest.requester.onBehalfOf",
"short": "Organization agent is acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when authoring the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.onBehalfOf"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "ProcedureRequest.performerType",
"path": "ProcedureRequest.performerType",
"short": "Performer role",
"definition": "Desired type of performer for doing the diagnostic testing.",
"comment": "this is a role, not a participation type. I.e. does not describe the task, but describes the capacity. For example, “compounding pharmacy” or “psychiatrist” or “internal referral”.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestParticipantRole"
}
],
"strength": "example",
"description": "Indicates specific responsibility of an individual within the care team, such as \"Primary physician\", \"Team coordinator\", \"Caregiver\", etc.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/participant-role"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.performerType"
},
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF].role[scoper.determinerCode=KIND].code"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "ProcedureRequest.performer",
"path": "ProcedureRequest.performer",
"short": "Requested perfomer",
"definition": "The desired perfomer for doing the diagnostic testing. For example, the surgeon, dermatopathologist, endoscopist, etc.",
"comment": "If needed, use an [extension](extensibility.html) for listing alternative performers and/or roles and/or preference.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/HealthcareService"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.Performer"
},
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF].role[scoper.determinerCode=INSTANCE]"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "ProcedureRequest.reasonCode",
"path": "ProcedureRequest.reasonCode",
"short": "Explanation/Justification for test",
"definition": "An explanation or justification for why this diagnostic investigation is being requested in coded or textual form. This is often for billing purposes. May relate to the resources referred to in supportingInformation.",
"comment": "This may be used to decide how the diagnostic investigation will be performed, or even if it will be performed at all. Use CodeableConcept text element if the data is free (uncoded) text as shown in the [CT Scan example](procedurerequest-example-di.html).",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestReason"
}
],
"strength": "example",
"description": "Diagnosis or problem codes justifying the reason for requesting the procedure or diagnostic investigation.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-reason"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.reasonCod"
},
{
"identity": "v2",
"map": "ORC.16"
},
{
"identity": "rim",
"map": ".reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ProcedureRequest.reasonReference",
"path": "ProcedureRequest.reasonReference",
"short": "Explanation/Justification for test",
"definition": "Indicates another resource that provides a justification for why this diagnostic investigation is being requested. May relate to the resources referred to in supportingInformation.",
"comment": "This may be used to decide how the diagnostic investigation will be performed, or even if it will be performed at all. Use CodeableConcept text element if the data is free (uncoded) text as shown in the [CT Scan example](procedurerequest-example-di.html).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.reasonReference"
},
{
"identity": "v2",
"map": "ORC.16"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON].target"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ProcedureRequest.supportingInfo",
"path": "ProcedureRequest.supportingInfo",
"short": "Additional clinical information",
"definition": "Additional clinical information about the patient or specimen that may influence the procedure or diagnostics or their interpretations. This information includes diagnosis, clinical findings and other observations. In laboratory ordering these are typically referred to as \"ask at order entry questions (AOEs)\". This includes observations explicitly requested by the producer (filler) to provide context or supporting information needed to complete the order. For example, reporting the amount of inspired oxygen for blood gas measurements.",
"alias": [
"Ask at order entry question",
"AOE"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.supportingInformation"
},
{
"identity": "v2",
"map": "Accompanying segments"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=PERT].target"
}
]
},
{
"id": "ProcedureRequest.specimen",
"path": "ProcedureRequest.specimen",
"short": "Procedure Samples",
"definition": "One or more specimens that the laboratory procedure will use.",
"comment": "Many diagnostic procedures need a specimen, but the request itself is not actually about the specimen. This element is for when the diagnostic is requested on already existing specimens and the request points to the specimen it applies to. Conversely, If the request is entered first with an unknown specimen, The [Specimen](specimen.html) resource references to the ProcedureRequest.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Specimen"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SPM"
},
{
"identity": "rim",
"map": ".participation[typeCode=SPC].role"
}
]
},
{
"id": "ProcedureRequest.bodySite",
"path": "ProcedureRequest.bodySite",
"short": "Location on Body",
"definition": "Anatomic location where the procedure should be performed. This is the target site.",
"comment": "Only used if not implicit in the code found in ProcedureRequest.type. If the use case requires BodySite to be handled as a separate resource instead of an inline coded element (e.g. to identify and track separately) then use the standard extension [procedurerequest-targetBodySite](extension-procedurerequest-targetbodysite.html).",
"requirements": "Knowing where the procedure is performed is important for tracking if multiple sites are possible.",
"alias": [
"location"
],
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "BodySite"
}
],
"strength": "example",
"description": "Codes describing anatomical locations. May include laterality.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/body-site"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM"
},
{
"identity": "rim",
"map": "targetSiteCode"
},
{
"identity": "quick",
"map": "Procedure.targetBodySite"
}
]
},
{
"id": "ProcedureRequest.note",
"path": "ProcedureRequest.note",
"short": "Comments",
"definition": "Any other notes and comments made about the service request. For example, letting provider know that \"patient hates needles\" or other provider instructions.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.note"
},
{
"identity": "v2",
"map": "NTE"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=ANNGEN, moodCode=EVN].value[xsi:type=ST]"
},
{
"identity": "quick",
"map": "ClinicalStatement.additionalText"
}
]
},
{
"id": "ProcedureRequest.relevantHistory",
"path": "ProcedureRequest.relevantHistory",
"short": "Request provenance",
"definition": "Key events in the history of the request.",
"comment": "This may not include provenances for all versions of the request – only those deemed “relevant” or important.\rThis SHALL NOT include the Provenance associated with this current version of the resource. (If that provenance is deemed to be a “relevant” change, it will need to be added as part of a later update. Until then, it can be queried directly as the Provenance that points to this version using _revinclude\rAll Provenances should have some historical version of this Request as their subject.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.relevantHistory"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
}
]
},
"differential": {
"element": [
{
"id": "ProcedureRequest",
"path": "ProcedureRequest",
"short": "A request for a procedure or diagnostic to be performed",
"definition": "A record of a request for diagnostic investigations, treatments, or operations to be performed.",
"alias": [
"diagnostic request"
],
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "v2",
"map": "ORC"
},
{
"identity": "rim",
"map": "Act[moodCode<=INT]"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "ProcedureRequest.identifier",
"path": "ProcedureRequest.identifier",
"short": "Identifiers assigned to this order",
"definition": "Identifiers assigned to this order instance by the orderer and/or the receiver and/or order fulfiller.",
"comment": "The identifier.type element is used to distinguish between the identifiers assigned by the orderer (known as the 'Placer' in HL7 v2) and the producer of the observations in response to the order (known as the 'Filler' in HL7 v2). For further discussion and examples see the resource notes section below.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "v2",
"map": "ORC.2, ORC.3"
},
{
"identity": "rim",
"map": ".identifier"
},
{
"identity": "quick",
"map": "ClinicalStatement.identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ProcedureRequest.definition",
"path": "ProcedureRequest.definition",
"short": "Protocol or definition",
"definition": "Protocol or definition followed by this request.",
"alias": [
"protocol"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.definition"
},
{
"identity": "v2",
"map": "Varies by domain"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target"
}
]
},
{
"id": "ProcedureRequest.basedOn",
"path": "ProcedureRequest.basedOn",
"short": "What request fulfills",
"definition": "Plan/proposal/order fulfilled by this request.",
"alias": [
"fulfills"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.basedOn"
},
{
"identity": "v2",
"map": "ORC.8 (plus others)"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target"
}
]
},
{
"id": "ProcedureRequest.replaces",
"path": "ProcedureRequest.replaces",
"short": "What request replaces",
"definition": "The request takes the place of the referenced completed or terminated request(s).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.replaces"
},
{
"identity": "v2",
"map": "Handled by message location of ORC (ORC.1=RO or RU)"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RPLC].target"
}
]
},
{
"id": "ProcedureRequest.requisition",
"path": "ProcedureRequest.requisition",
"short": "Composite Request ID",
"definition": "A shared identifier common to all procedure or diagnostic requests that were authorized more or less simultaneously by a single author, representing the composite or group identifier.",
"comment": "Requests are linked either by a \"basedOn\" relationship (i.e. one request is fulfilling another) or by having a common requisition. Requests that are part of the same requisition are generally treated independently from the perspective of changing their state or maintaining them after initial creation.",
"requirements": "Some business processes need to know if multiple items were ordered as part of the same \"requisition\" for billing or other purposes.",
"alias": [
"grouperId",
"groupIdentifier"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "ORC.4"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=COMP].source[moodCode=INT].identifier"
}
]
},
{
"id": "ProcedureRequest.status",
"path": "ProcedureRequest.status",
"short": "draft | active | suspended | completed | entered-in-error | cancelled",
"definition": "The status of the order.",
"comment": "The status is generally fully in the control of the requester - they determine whether the order is draft or active and, after it has been activated, competed, cancelled or suspended. States relating to the activities of the performer are reflected on either the corresponding event (see [Event Pattern](event.html) for general discussion) or using the [Task](task.html) resource.\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestStatus"
}
],
"strength": "required",
"description": "The status of a procedure or diagnostic order.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "v2",
"map": "ORC.5"
},
{
"identity": "rim",
"map": ".status"
},
{
"identity": "quick",
"map": "Action.currentStatus"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ProcedureRequest.intent",
"path": "ProcedureRequest.intent",
"short": "proposal | plan | order +",
"definition": "Whether the request is a proposal, plan, an original order or a reflex order.",
"comment": "This element is labeled as a modifier because the intent alters when and how the resource is actually applicable.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestIntent"
}
],
"strength": "required",
"description": "The kind of procedure or diagnostic request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-intent"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.intent"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".moodCode (nuances beyond PRP/PLAN/RQO would need to be elsewhere)"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ProcedureRequest.priority",
"path": "ProcedureRequest.priority",
"short": "routine | urgent | asap | stat",
"definition": "Indicates how quickly the ProcedureRequest should be addressed with respect to other requests.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "If missing, this task should be performed with normal priority",
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestPriority"
}
],
"strength": "required",
"description": "Identifies the level of importance to be assigned to actioning the request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-priority"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.priority"
},
{
"identity": "v2",
"map": "TQ1.9"
},
{
"identity": "rim",
"map": ".priorityCode"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ProcedureRequest.doNotPerform",
"path": "ProcedureRequest.doNotPerform",
"short": "True if procedure should not be performed",
"definition": "Set this to true if the record is saying that the procedure should NOT be performed.",
"comment": "This element is labeled as a [modifier](conformance-rules.html#isModifier.html) because it indicates that a procedure shouldn't happen, instead of a request for it to happen. In general, only the code and timeframe will be present, though occasional additional qualifiers such as body site or even performer could be included to narrow the scope of the prohibition. If the ProcedureRequest.code and ProcedureRequest.doNotPerform both contain negation, that will reinforce prohibition and should not have a double negative interpretation.",
"requirements": "Used for do not ambulate, do not elevate head of bed, do not flush NG tube, do not take blood pressure on a certain arm, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".actionNegationInd"
}
]
},
{
"id": "ProcedureRequest.category",
"path": "ProcedureRequest.category",
"short": "Classification of procedure",
"definition": "A code that classifies the procedure for searching, sorting and display purposes (e.g. \"Surgical Procedure\").",
"comment": "There may be multiple axis of categorization depending on the context or use case for retrieving or displaying the resource. The level of granularity is defined by the category concepts in the value set.",
"requirements": "Used for filtering what procedure request are retrieved and displayed.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestCategory"
}
],
"strength": "example",
"description": "Classification of the procedure",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"COMP].target[classCode=\"LIST\", moodCode=\"INT\"].code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ProcedureRequest.code",
"path": "ProcedureRequest.code",
"short": "What is being requested/ordered",
"definition": "A code that identifies a particular procedure, diagnostic investigation, or panel of investigations, that have been requested.",
"comment": "Many laboratory and radiology procedure codes embed the specimen/organ system in the test ordeer name, for example, serum or serum/plasma glucose, or a chest xray. The specimen may not be recorded separately from the test code.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestCode"
}
],
"strength": "example",
"description": "Codes for tests/services that can be performed by procedure or diagnostic services. For laboratory, LOINC is (preferred)[http://build.fhir.org/terminologies.html#preferred] and a valueset using LOINC Order codes is available [here](valueset-diagnostic-requests.html).",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-code"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.code"
},
{
"identity": "v2",
"map": "Varies by domain"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "quick",
"map": "Procedure.procedureCode"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "ProcedureRequest.subject",
"path": "ProcedureRequest.subject",
"short": "Individual the service is ordered for",
"definition": "On whom or what the procedure or diagnostic is to be performed. This is usually a human patient, but can also be requested on animals, groups of humans or animals, devices such as dialysis machines, or even locations (typically for environmental scans).",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.subject"
},
{
"identity": "v2",
"map": "Accompanying PID segment"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
},
{
"identity": "quick",
"map": "ClinicalStatement.subject"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "ProcedureRequest.context",
"path": "ProcedureRequest.context",
"short": "Encounter or Episode during which request was created",
"definition": "An encounter or episode of care that provides additional information about the healthcare context in which this request is made.",
"alias": [
"encounter"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.context"
},
{
"identity": "v2",
"map": "Accompanying PV1"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=COMP].source[classCode<=PCPR, moodCode=EVN]"
},
{
"identity": "quick",
"map": "ClinicalStatement.encounter"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "ProcedureRequest.occurrence[x]",
"path": "ProcedureRequest.occurrence[x]",
"short": "When procedure should occur",
"definition": "The date/time at which the diagnostic testing should occur.",
"alias": [
"schedule"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
},
{
"code": "Timing"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.occurrence[x]"
},
{
"identity": "v2",
"map": "Accompanying TQ1/TQ2 segments"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "quick",
"map": "Procedure.procedureSchedule"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "ProcedureRequest.asNeeded[x]",
"path": "ProcedureRequest.asNeeded[x]",
"short": "Preconditions for procedure or diagnostic",
"definition": "If a CodeableConcept is present, it indicates the pre-condition for performing the procedure. For example \"pain\", \"on flare-up\", etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureAsNeededReason"
}
],
"strength": "example",
"description": "A coded concept identifying the pre-condition that should hold prior to performing a procedure. For example \"pain\", \"on flare-up\", etc.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/medication-as-needed-reason"
}
},
"mapping": [
{
"identity": "rim",
"map": "boolean: precondition.negationInd (inversed - so negationInd = true means asNeeded=false CodeableConcept: precondition.observationEventCriterion[code=\"Assertion\"].value"
},
{
"identity": "quick",
"map": "Proposal.prnReason.reason"
}
]
},
{
"id": "ProcedureRequest.authoredOn",
"path": "ProcedureRequest.authoredOn",
"short": "Date request signed",
"definition": "When the request transitioned to being actionable.",
"alias": [
"orderedOn"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "v2",
"map": "ORC.9"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "quick",
"map": "Proposal.proposedAtTime"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ProcedureRequest.requester",
"path": "ProcedureRequest.requester",
"short": "Who/what is requesting procedure or diagnostic",
"definition": "The individual who initiated the request and has responsibility for its activation.",
"comment": "This not the dispatcher, but rather who is the authorizer.",
"alias": [
"author",
"orderer"
],
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester"
},
{
"identity": "v2",
"map": "ORC.12"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "quick",
"map": "ClinicalStatement.statementAuthor"
}
]
},
{
"id": "ProcedureRequest.requester.agent",
"path": "ProcedureRequest.requester.agent",
"short": "Individual making the request",
"definition": "The device, practitioner or organization who initiated the request.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.agent"
},
{
"identity": "v2",
"map": "ORC.12"
},
{
"identity": "rim",
"map": ".player"
},
{
"identity": "quick",
"map": "ClinicalStatement.statementAuthor"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "ProcedureRequest.requester.onBehalfOf",
"path": "ProcedureRequest.requester.onBehalfOf",
"short": "Organization agent is acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when authoring the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.onBehalfOf"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "ProcedureRequest.performerType",
"path": "ProcedureRequest.performerType",
"short": "Performer role",
"definition": "Desired type of performer for doing the diagnostic testing.",
"comment": "this is a role, not a participation type. I.e. does not describe the task, but describes the capacity. For example, “compounding pharmacy” or “psychiatrist” or “internal referral”.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestParticipantRole"
}
],
"strength": "example",
"description": "Indicates specific responsibility of an individual within the care team, such as \"Primary physician\", \"Team coordinator\", \"Caregiver\", etc.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/participant-role"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.performerType"
},
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF].role[scoper.determinerCode=KIND].code"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "ProcedureRequest.performer",
"path": "ProcedureRequest.performer",
"short": "Requested perfomer",
"definition": "The desired perfomer for doing the diagnostic testing. For example, the surgeon, dermatopathologist, endoscopist, etc.",
"comment": "If needed, use an [extension](extensibility.html) for listing alternative performers and/or roles and/or preference.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/HealthcareService"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.Performer"
},
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF].role[scoper.determinerCode=INSTANCE]"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "ProcedureRequest.reasonCode",
"path": "ProcedureRequest.reasonCode",
"short": "Explanation/Justification for test",
"definition": "An explanation or justification for why this diagnostic investigation is being requested in coded or textual form. This is often for billing purposes. May relate to the resources referred to in supportingInformation.",
"comment": "This may be used to decide how the diagnostic investigation will be performed, or even if it will be performed at all. Use CodeableConcept text element if the data is free (uncoded) text as shown in the [CT Scan example](procedurerequest-example-di.html).",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcedureRequestReason"
}
],
"strength": "example",
"description": "Diagnosis or problem codes justifying the reason for requesting the procedure or diagnostic investigation.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/procedure-reason"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.reasonCod"
},
{
"identity": "v2",
"map": "ORC.16"
},
{
"identity": "rim",
"map": ".reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ProcedureRequest.reasonReference",
"path": "ProcedureRequest.reasonReference",
"short": "Explanation/Justification for test",
"definition": "Indicates another resource that provides a justification for why this diagnostic investigation is being requested. May relate to the resources referred to in supportingInformation.",
"comment": "This may be used to decide how the diagnostic investigation will be performed, or even if it will be performed at all. Use CodeableConcept text element if the data is free (uncoded) text as shown in the [CT Scan example](procedurerequest-example-di.html).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.reasonReference"
},
{
"identity": "v2",
"map": "ORC.16"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON].target"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ProcedureRequest.supportingInfo",
"path": "ProcedureRequest.supportingInfo",
"short": "Additional clinical information",
"definition": "Additional clinical information about the patient or specimen that may influence the procedure or diagnostics or their interpretations. This information includes diagnosis, clinical findings and other observations. In laboratory ordering these are typically referred to as \"ask at order entry questions (AOEs)\". This includes observations explicitly requested by the producer (filler) to provide context or supporting information needed to complete the order. For example, reporting the amount of inspired oxygen for blood gas measurements.",
"alias": [
"Ask at order entry question",
"AOE"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.supportingInformation"
},
{
"identity": "v2",
"map": "Accompanying segments"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=PERT].target"
}
]
},
{
"id": "ProcedureRequest.specimen",
"path": "ProcedureRequest.specimen",
"short": "Procedure Samples",
"definition": "One or more specimens that the laboratory procedure will use.",
"comment": "Many diagnostic procedures need a specimen, but the request itself is not actually about the specimen. This element is for when the diagnostic is requested on already existing specimens and the request points to the specimen it applies to. Conversely, If the request is entered first with an unknown specimen, The [Specimen](specimen.html) resource references to the ProcedureRequest.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Specimen"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SPM"
},
{
"identity": "rim",
"map": ".participation[typeCode=SPC].role"
}
]
},
{
"id": "ProcedureRequest.bodySite",
"path": "ProcedureRequest.bodySite",
"short": "Location on Body",
"definition": "Anatomic location where the procedure should be performed. This is the target site.",
"comment": "Only used if not implicit in the code found in ProcedureRequest.type. If the use case requires BodySite to be handled as a separate resource instead of an inline coded element (e.g. to identify and track separately) then use the standard extension [procedurerequest-targetBodySite](extension-procedurerequest-targetbodysite.html).",
"requirements": "Knowing where the procedure is performed is important for tracking if multiple sites are possible.",
"alias": [
"location"
],
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "BodySite"
}
],
"strength": "example",
"description": "Codes describing anatomical locations. May include laterality.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/body-site"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM"
},
{
"identity": "rim",
"map": "targetSiteCode"
},
{
"identity": "quick",
"map": "Procedure.targetBodySite"
}
]
},
{
"id": "ProcedureRequest.note",
"path": "ProcedureRequest.note",
"short": "Comments",
"definition": "Any other notes and comments made about the service request. For example, letting provider know that \"patient hates needles\" or other provider instructions.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.note"
},
{
"identity": "v2",
"map": "NTE"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=ANNGEN, moodCode=EVN].value[xsi:type=ST]"
},
{
"identity": "quick",
"map": "ClinicalStatement.additionalText"
}
]
},
{
"id": "ProcedureRequest.relevantHistory",
"path": "ProcedureRequest.relevantHistory",
"short": "Request provenance",
"definition": "Key events in the history of the request.",
"comment": "This may not include provenances for all versions of the request – only those deemed “relevant” or important.\rThis SHALL NOT include the Provenance associated with this current version of the resource. (If that provenance is deemed to be a “relevant” change, it will need to be added as part of a later update. Until then, it can be queried directly as the Provenance that points to this version using _revinclude\rAll Provenances should have some historical version of this Request as their subject.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.relevantHistory"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/ProcessRequest",
"resource": {
"resourceType": "StructureDefinition",
"id": "ProcessRequest",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints ProcessRequest DomainResource Request to perform some action on or in regards to an existing resource
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..* Identifier Business Identifier
status ?!Σ 0..1 code active | cancelled | draft | entered-in-error
Financial Resource Status Codes (Required) action 0..1 code cancel | poll | reprocess | status
ActionList (Required) target 0..1 Reference(Organization) Party which is the target of the request created 0..1 dateTime Creation date provider 0..1 Reference(Practitioner) Responsible practitioner organization 0..1 Reference(Organization) Responsible organization request 0..1 Reference(Any) Reference to the Request resource response 0..1 Reference(Any) Reference to the Response resource nullify 0..1 boolean Remove history reference 0..1 string Reference number/string item 0..* BackboneElement Items to re-adjudicate
sequenceLinkId 1..1 integer Service instance include 0..* string Resource type(s) to include
exclude 0..* string Resource type(s) to exclude
period 0..1 Period Selection period
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fm"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/ProcessRequest",
"name": "ProcessRequest",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Financial Management)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for ProcessRequest Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "cdanetv4",
"uri": "http://www.cda-adc.ca/en/services/cdanet/",
"name": "Canadian Dental Association eclaims standard"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "ProcessRequest",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "ProcessRequest",
"path": "ProcessRequest",
"short": "Request to perform some action on or in regards to an existing resource",
"definition": "This resource provides the target, request and response, and action details for an action to be performed by the target on or about existing resources.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "w5",
"map": "workflow.order"
}
]
},
{
"id": "ProcessRequest.id",
"path": "ProcessRequest.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "ProcessRequest.meta",
"path": "ProcessRequest.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "ProcessRequest.implicitRules",
"path": "ProcessRequest.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "ProcessRequest.language",
"path": "ProcessRequest.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "ProcessRequest.text",
"path": "ProcessRequest.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "ProcessRequest.contained",
"path": "ProcessRequest.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcessRequest.extension",
"path": "ProcessRequest.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcessRequest.modifierExtension",
"path": "ProcessRequest.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcessRequest.identifier",
"path": "ProcessRequest.identifier",
"short": "Business Identifier",
"definition": "The ProcessRequest business identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ProcessRequest.status",
"path": "ProcessRequest.status",
"short": "active | cancelled | draft | entered-in-error",
"definition": "The status of the resource instance.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcessRequestStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the resource instance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/fm-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ProcessRequest.action",
"path": "ProcessRequest.action",
"short": "cancel | poll | reprocess | status",
"definition": "The type of processing action being requested, for example Reversal, Readjudication, StatusRequest,PendedRequest.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionList"
}
],
"strength": "required",
"description": "List of allowable action which this resource can request.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/actionlist"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ProcessRequest.target",
"path": "ProcessRequest.target",
"short": "Party which is the target of the request",
"definition": "The organization which is the target of the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "ProcessRequest.created",
"path": "ProcessRequest.created",
"short": "Creation date",
"definition": "The date when this resource was created.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ProcessRequest.provider",
"path": "ProcessRequest.provider",
"short": "Responsible practitioner",
"definition": "The practitioner who is responsible for the action specified in this request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.agent"
},
{
"identity": "cdanetv4",
"map": "B01"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "ProcessRequest.organization",
"path": "ProcessRequest.organization",
"short": "Responsible organization",
"definition": "The organization which is responsible for the action speccified in this request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.onBehalfOf"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "ProcessRequest.request",
"path": "ProcessRequest.request",
"short": "Reference to the Request resource",
"definition": "Reference of resource which is the target or subject of this action.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.basedOn"
}
]
},
{
"id": "ProcessRequest.response",
"path": "ProcessRequest.response",
"short": "Reference to the Response resource",
"definition": "Reference of a prior response to resource which is the target or subject of this action.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "ProcessRequest.nullify",
"path": "ProcessRequest.nullify",
"short": "Remove history",
"definition": "If true remove all history excluding audit.",
"requirements": "Some resources must not simply be reversed in a processing or accounting sense but rather must have all history removed, such as the accidental submission of sensitive and/or wrong information. If the receiver cannot comply with a Nullify request then they must reject the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
]
},
{
"id": "ProcessRequest.reference",
"path": "ProcessRequest.reference",
"short": "Reference number/string",
"definition": "A reference to supply which authenticates the process.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ProcessRequest.item",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Items"
}
],
"path": "ProcessRequest.item",
"short": "Items to re-adjudicate",
"definition": "List of top level items to be re-adjudicated, if none specified then the entire submission is re-adjudicated.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "ProcessRequest.item.id",
"path": "ProcessRequest.item.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ProcessRequest.item.extension",
"path": "ProcessRequest.item.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ProcessRequest.item.modifierExtension",
"path": "ProcessRequest.item.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcessRequest.item.sequenceLinkId",
"path": "ProcessRequest.item.sequenceLinkId",
"short": "Service instance",
"definition": "A service line number.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "ProcessRequest.include",
"path": "ProcessRequest.include",
"short": "Resource type(s) to include",
"definition": "Names of resource types to include.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
]
},
{
"id": "ProcessRequest.exclude",
"path": "ProcessRequest.exclude",
"short": "Resource type(s) to exclude",
"definition": "Names of resource types to exclude.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
]
},
{
"id": "ProcessRequest.period",
"path": "ProcessRequest.period",
"short": "Selection period",
"definition": "A period of time during which the fulfilling resources would have been created.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
]
}
]
},
"differential": {
"element": [
{
"id": "ProcessRequest",
"path": "ProcessRequest",
"short": "Request to perform some action on or in regards to an existing resource",
"definition": "This resource provides the target, request and response, and action details for an action to be performed by the target on or about existing resources.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "w5",
"map": "workflow.order"
}
]
},
{
"id": "ProcessRequest.identifier",
"path": "ProcessRequest.identifier",
"short": "Business Identifier",
"definition": "The ProcessRequest business identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ProcessRequest.status",
"path": "ProcessRequest.status",
"short": "active | cancelled | draft | entered-in-error",
"definition": "The status of the resource instance.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcessRequestStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the resource instance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/fm-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ProcessRequest.action",
"path": "ProcessRequest.action",
"short": "cancel | poll | reprocess | status",
"definition": "The type of processing action being requested, for example Reversal, Readjudication, StatusRequest,PendedRequest.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionList"
}
],
"strength": "required",
"description": "List of allowable action which this resource can request.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/actionlist"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ProcessRequest.target",
"path": "ProcessRequest.target",
"short": "Party which is the target of the request",
"definition": "The organization which is the target of the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "ProcessRequest.created",
"path": "ProcessRequest.created",
"short": "Creation date",
"definition": "The date when this resource was created.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ProcessRequest.provider",
"path": "ProcessRequest.provider",
"short": "Responsible practitioner",
"definition": "The practitioner who is responsible for the action specified in this request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.agent"
},
{
"identity": "cdanetv4",
"map": "B01"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "ProcessRequest.organization",
"path": "ProcessRequest.organization",
"short": "Responsible organization",
"definition": "The organization which is responsible for the action speccified in this request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.onBehalfOf"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "ProcessRequest.request",
"path": "ProcessRequest.request",
"short": "Reference to the Request resource",
"definition": "Reference of resource which is the target or subject of this action.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.basedOn"
}
]
},
{
"id": "ProcessRequest.response",
"path": "ProcessRequest.response",
"short": "Reference to the Response resource",
"definition": "Reference of a prior response to resource which is the target or subject of this action.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "ProcessRequest.nullify",
"path": "ProcessRequest.nullify",
"short": "Remove history",
"definition": "If true remove all history excluding audit.",
"requirements": "Some resources must not simply be reversed in a processing or accounting sense but rather must have all history removed, such as the accidental submission of sensitive and/or wrong information. If the receiver cannot comply with a Nullify request then they must reject the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
]
},
{
"id": "ProcessRequest.reference",
"path": "ProcessRequest.reference",
"short": "Reference number/string",
"definition": "A reference to supply which authenticates the process.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ProcessRequest.item",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Items"
}
],
"path": "ProcessRequest.item",
"short": "Items to re-adjudicate",
"definition": "List of top level items to be re-adjudicated, if none specified then the entire submission is re-adjudicated.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "ProcessRequest.item.sequenceLinkId",
"path": "ProcessRequest.item.sequenceLinkId",
"short": "Service instance",
"definition": "A service line number.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "ProcessRequest.include",
"path": "ProcessRequest.include",
"short": "Resource type(s) to include",
"definition": "Names of resource types to include.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
]
},
{
"id": "ProcessRequest.exclude",
"path": "ProcessRequest.exclude",
"short": "Resource type(s) to exclude",
"definition": "Names of resource types to exclude.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
]
},
{
"id": "ProcessRequest.period",
"path": "ProcessRequest.period",
"short": "Selection period",
"definition": "A period of time during which the fulfilling resources would have been created.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/ProcessResponse",
"resource": {
"resourceType": "StructureDefinition",
"id": "ProcessResponse",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints ProcessResponse DomainResource ProcessResponse resource
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..* Identifier Business Identifier
status ?!Σ 0..1 code active | cancelled | draft | entered-in-error
Financial Resource Status Codes (Required) created 0..1 dateTime Creation date organization 0..1 Reference(Organization) Authoring Organization request 0..1 Reference(Any) Request reference outcome 0..1 CodeableConcept Processing outcome
Process Outcome Codes (Example) disposition 0..1 string Disposition Message requestProvider 0..1 Reference(Practitioner) Responsible Practitioner requestOrganization 0..1 Reference(Organization) Responsible organization form 0..1 CodeableConcept Printed Form Identifier
Form Codes (Example) processNote 0..* BackboneElement Processing comments or additional requirements
type 0..1 CodeableConcept display | print | printoper
NoteType (Required) text 0..1 string Comment on the processing error 0..* CodeableConcept Error code
Adjudication Error Codes (Example)
communicationRequest 0..* Reference(CommunicationRequest) Request for additional information
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fm"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/ProcessResponse",
"name": "ProcessResponse",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Financial Management)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for ProcessResponse Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "cdanetv4",
"uri": "http://www.cda-adc.ca/en/services/cdanet/",
"name": "Canadian Dental Association eclaims standard"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "ProcessResponse",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "ProcessResponse",
"path": "ProcessResponse",
"short": "ProcessResponse resource",
"definition": "This resource provides processing status, errors and notes from the processing of a resource.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "w5",
"map": "workflow.order"
}
]
},
{
"id": "ProcessResponse.id",
"path": "ProcessResponse.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "ProcessResponse.meta",
"path": "ProcessResponse.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "ProcessResponse.implicitRules",
"path": "ProcessResponse.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "ProcessResponse.language",
"path": "ProcessResponse.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "ProcessResponse.text",
"path": "ProcessResponse.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "ProcessResponse.contained",
"path": "ProcessResponse.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcessResponse.extension",
"path": "ProcessResponse.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcessResponse.modifierExtension",
"path": "ProcessResponse.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcessResponse.identifier",
"path": "ProcessResponse.identifier",
"short": "Business Identifier",
"definition": "The Response business identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ProcessResponse.status",
"path": "ProcessResponse.status",
"short": "active | cancelled | draft | entered-in-error",
"definition": "The status of the resource instance.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcessResponseStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the resource instance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/fm-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ProcessResponse.created",
"path": "ProcessResponse.created",
"short": "Creation date",
"definition": "The date when the enclosed suite of services were performed or completed.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ProcessResponse.organization",
"path": "ProcessResponse.organization",
"short": "Authoring Organization",
"definition": "The organization who produced this adjudicated response.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.onBehalfOf"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "ProcessResponse.request",
"path": "ProcessResponse.request",
"short": "Request reference",
"definition": "Original request resource reference.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "A02|G01"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ProcessResponse.outcome",
"path": "ProcessResponse.outcome",
"short": "Processing outcome",
"definition": "Transaction status: error, complete, held.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcessingOutcome"
}
],
"strength": "example",
"description": "Local status of outcome codes",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/process-outcome"
}
}
},
{
"id": "ProcessResponse.disposition",
"path": "ProcessResponse.disposition",
"short": "Disposition Message",
"definition": "A description of the status of the adjudication or processing.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.note"
}
]
},
{
"id": "ProcessResponse.requestProvider",
"path": "ProcessResponse.requestProvider",
"short": "Responsible Practitioner",
"definition": "The practitioner who is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "B01"
}
]
},
{
"id": "ProcessResponse.requestOrganization",
"path": "ProcessResponse.requestOrganization",
"short": "Responsible organization",
"definition": "The organization which is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
]
},
{
"id": "ProcessResponse.form",
"path": "ProcessResponse.form",
"short": "Printed Form Identifier",
"definition": "The form to be used for printing the content.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Forms"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "example",
"description": "The forms codes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/forms"
}
},
"mapping": [
{
"identity": "cdanetv4",
"map": "G42"
}
]
},
{
"id": "ProcessResponse.processNote",
"path": "ProcessResponse.processNote",
"short": "Processing comments or additional requirements",
"definition": "Suite of processing notes or additional requirements if the processing has been held.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "ProcessResponse.processNote.id",
"path": "ProcessResponse.processNote.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ProcessResponse.processNote.extension",
"path": "ProcessResponse.processNote.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ProcessResponse.processNote.modifierExtension",
"path": "ProcessResponse.processNote.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ProcessResponse.processNote.type",
"path": "ProcessResponse.processNote.type",
"short": "display | print | printoper",
"definition": "The note purpose: Print/Display.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NoteType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The presentation types of notes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/note-type"
}
}
},
{
"id": "ProcessResponse.processNote.text",
"path": "ProcessResponse.processNote.text",
"short": "Comment on the processing",
"definition": "The note text.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "G32"
}
]
},
{
"id": "ProcessResponse.error",
"path": "ProcessResponse.error",
"short": "Error code",
"definition": "Processing errors.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdjudicationError"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "example",
"description": "The error codes for adjudication processing.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/adjudication-error"
}
}
},
{
"id": "ProcessResponse.communicationRequest",
"path": "ProcessResponse.communicationRequest",
"short": "Request for additional information",
"definition": "Request for additional supporting or authorizing information, such as: documents, images or resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CommunicationRequest"
}
]
}
]
},
"differential": {
"element": [
{
"id": "ProcessResponse",
"path": "ProcessResponse",
"short": "ProcessResponse resource",
"definition": "This resource provides processing status, errors and notes from the processing of a resource.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "w5",
"map": "workflow.order"
}
]
},
{
"id": "ProcessResponse.identifier",
"path": "ProcessResponse.identifier",
"short": "Business Identifier",
"definition": "The Response business identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ProcessResponse.status",
"path": "ProcessResponse.status",
"short": "active | cancelled | draft | entered-in-error",
"definition": "The status of the resource instance.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcessResponseStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the resource instance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/fm-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ProcessResponse.created",
"path": "ProcessResponse.created",
"short": "Creation date",
"definition": "The date when the enclosed suite of services were performed or completed.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ProcessResponse.organization",
"path": "ProcessResponse.organization",
"short": "Authoring Organization",
"definition": "The organization who produced this adjudicated response.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.onBehalfOf"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "ProcessResponse.request",
"path": "ProcessResponse.request",
"short": "Request reference",
"definition": "Original request resource reference.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "A02|G01"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ProcessResponse.outcome",
"path": "ProcessResponse.outcome",
"short": "Processing outcome",
"definition": "Transaction status: error, complete, held.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProcessingOutcome"
}
],
"strength": "example",
"description": "Local status of outcome codes",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/process-outcome"
}
}
},
{
"id": "ProcessResponse.disposition",
"path": "ProcessResponse.disposition",
"short": "Disposition Message",
"definition": "A description of the status of the adjudication or processing.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.note"
}
]
},
{
"id": "ProcessResponse.requestProvider",
"path": "ProcessResponse.requestProvider",
"short": "Responsible Practitioner",
"definition": "The practitioner who is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "B01"
}
]
},
{
"id": "ProcessResponse.requestOrganization",
"path": "ProcessResponse.requestOrganization",
"short": "Responsible organization",
"definition": "The organization which is responsible for the services rendered to the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
]
},
{
"id": "ProcessResponse.form",
"path": "ProcessResponse.form",
"short": "Printed Form Identifier",
"definition": "The form to be used for printing the content.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Forms"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "example",
"description": "The forms codes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/forms"
}
},
"mapping": [
{
"identity": "cdanetv4",
"map": "G42"
}
]
},
{
"id": "ProcessResponse.processNote",
"path": "ProcessResponse.processNote",
"short": "Processing comments or additional requirements",
"definition": "Suite of processing notes or additional requirements if the processing has been held.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "ProcessResponse.processNote.type",
"path": "ProcessResponse.processNote.type",
"short": "display | print | printoper",
"definition": "The note purpose: Print/Display.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "NoteType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The presentation types of notes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/note-type"
}
}
},
{
"id": "ProcessResponse.processNote.text",
"path": "ProcessResponse.processNote.text",
"short": "Comment on the processing",
"definition": "The note text.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "cdanetv4",
"map": "G32"
}
]
},
{
"id": "ProcessResponse.error",
"path": "ProcessResponse.error",
"short": "Error code",
"definition": "Processing errors.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdjudicationError"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "example",
"description": "The error codes for adjudication processing.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/adjudication-error"
}
}
},
{
"id": "ProcessResponse.communicationRequest",
"path": "ProcessResponse.communicationRequest",
"short": "Request for additional information",
"definition": "Request for additional supporting or authorizing information, such as: documents, images or resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CommunicationRequest"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Provenance",
"resource": {
"resourceType": "StructureDefinition",
"id": "Provenance",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Provenance DomainResource Who, What, When for a set of resources
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension target Σ 1..* Reference(Any) Target Reference(s) (usually version specific)
period 0..1 Period When the activity occurred recorded Σ 1..1 instant When the activity was recorded / updated policy 0..* uri Policy or plan the activity was defined by
location 0..1 Reference(Location) Where the activity occurred, if relevant reason 0..* Coding Reason the activity is occurring
PurposeOfUse (Extensible)
activity 0..1 Coding Activity that occurred
ProvenanceActivityType (Extensible) agent 1..* BackboneElement Actor involved
role Σ 0..* CodeableConcept What the agents role was
SecurityRoleType (Extensible)
who[x] Σ 1..1 Who participated whoUri uri whoReference Reference(Practitioner | RelatedPerson | Patient | Device | Organization) onBehalfOf[x] 0..1 Who the agent is representing onBehalfOfUri uri onBehalfOfReference Reference(Practitioner | RelatedPerson | Patient | Device | Organization) relatedAgentType 0..1 CodeableConcept Type of relationship between agents
v3 Code System RoleLinkType (Example) entity 0..* BackboneElement An entity used in this activity
role Σ 1..1 code derivation | revision | quotation | source | removal
ProvenanceEntityRole (Required) what[x] Σ 1..1 Identity of entity whatUri uri whatReference Reference(Any) whatIdentifier Identifier agent 0..* see agent Entity is attributed to this agent
signature 0..* Signature Signature on target
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "sec"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Provenance",
"name": "Provenance",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Security)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/secure/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Provenance Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w3c.prov",
"uri": "http://www.w3.org/ns/prov",
"name": "W3C PROV"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "fhirauditevent",
"uri": "http://hl7.org/fhir/auditevent",
"name": "FHIR AuditEvent"
}
],
"kind": "resource",
"abstract": false,
"type": "Provenance",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Provenance",
"path": "Provenance",
"short": "Who, What, When for a set of resources",
"definition": "Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies.",
"comment": "Some parties may be duplicated between the target resource and its provenance. For instance, the prescriber is usually (but not always) the author of the prescription resource. This resource is defined with close consideration for W3C Provenance.",
"alias": [
"History",
"Event",
"Activity"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "ControlAct[isNormalAct() and subsumes(CACT, classCode) and moodCode=EVN]"
},
{
"identity": "w3c.prov",
"map": "Activity"
},
{
"identity": "w5",
"map": "infrastructure.information"
}
]
},
{
"id": "Provenance.id",
"path": "Provenance.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Provenance.meta",
"path": "Provenance.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Provenance.implicitRules",
"path": "Provenance.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Provenance.language",
"path": "Provenance.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Provenance.text",
"path": "Provenance.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Provenance.contained",
"path": "Provenance.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Provenance.extension",
"path": "Provenance.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Provenance.modifierExtension",
"path": "Provenance.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Provenance.target",
"path": "Provenance.target",
"short": "Target Reference(s) (usually version specific)",
"definition": "The Reference(s) that were generated or updated by the activity described in this resource. A provenance can point to more than one target if multiple resources were created/updated by the same activity.",
"comment": "Target references are usually version specific, but may not be, if a version has not been assigned or if the provenance information is part of the set of resources being maintained (i.e. a document). When using the RESTful API, the identity of the resource may not be known (especially not the version specific one); the client may either submit the resource first, and then the provenance, or it may submit both using a single transaction. See the notes on transaction for further discussion.",
"min": 1,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "./outboundRelationship[isNormalActRelationship() and typeCode=SUBJ]/target OR ./participation[isNormalParticipation() and typeCode=SBJ]/role OR ./participation[isNormalParticipation() and typeCode=SBJ]/role[isNormalRole()]/player"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.entity.reference"
},
{
"identity": "w3c.prov",
"map": "Entity Created/Updated"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Provenance.period",
"path": "Provenance.period",
"short": "When the activity occurred",
"definition": "The period during which the activity occurred.",
"comment": "The period can be a little arbitrary; where possible, the time should correspond to human assessment of the activity time.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": "./effectiveTime[type=IVL_TS]"
},
{
"identity": "w3c.prov",
"map": "Activity.startTime & Activity.endTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Provenance.recorded",
"path": "Provenance.recorded",
"short": "When the activity was recorded / updated",
"definition": "The instant of time at which the activity was recorded.",
"comment": "This can be a little different from the time stamp on the resource if there is a delay between recording the event and updating the provenance and target resource.",
"min": 1,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "unique(./participation[isNormalParticipation() and typeCode=AUT]/time[type=TS])"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.recorded"
},
{
"identity": "w3c.prov",
"map": "Activity.when"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "Provenance.policy",
"path": "Provenance.policy",
"short": "Policy or plan the activity was defined by",
"definition": "Policy or plan the activity was defined by. Typically, a single activity may have multiple applicable policy documents, such as patient consent, guarantor funding, etc.",
"comment": "For example: Where an OAuth token authorizes, the unique identifier from the OAuth token is placed into the policy element Where a policy engine (e.g. XACML) holds policy logic, the unique policy identifier is placed into the policy element.",
"min": 0,
"max": "*",
"type": [
{
"code": "uri"
}
],
"mapping": [
{
"identity": "rim",
"map": "./inboundRelationship[isNormalActRelationship() and typeCode=\"SUBJ\"]/source[isNormalAct and subsumes(POLICY, classCode) and moodCode=EVN]/text[typeCode='ED'/tel"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.agent.policy"
}
]
},
{
"id": "Provenance.location",
"path": "Provenance.location",
"short": "Where the activity occurred, if relevant",
"definition": "Where the activity occurred, if relevant.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"mapping": [
{
"identity": "rim",
"map": "unique(./participation[isNormalParticipation() and typeCode=LOC]/role[isNormalRole() and subsumes(SDLOC, classCode)]/player[isNormalEntity and classCode=\"LOC\" and determinerCode=\"INST\"]"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.agent.location"
},
{
"identity": "w3c.prov",
"map": "Activity.location"
},
{
"identity": "w5",
"map": "where"
}
]
},
{
"id": "Provenance.reason",
"path": "Provenance.reason",
"short": "Reason the activity is occurring",
"definition": "The reason that the activity was taking place.",
"min": 0,
"max": "*",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProvenanceReason"
}
],
"strength": "extensible",
"description": "The reason the activity took place.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-PurposeOfUse"
}
},
"mapping": [
{
"identity": "rim",
"map": "unique(./reasonCode)"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.purposeOfEvent"
},
{
"identity": "w3c.prov",
"map": "Activity.Activity"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Provenance.activity",
"path": "Provenance.activity",
"short": "Activity that occurred",
"definition": "An activity is something that occurs over a period of time and acts upon or with entities; it may include consuming, processing, transforming, modifying, relocating, using, or generating entities.",
"min": 0,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProvenanceActivity"
}
],
"strength": "extensible",
"description": "The activity that took place.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/provenance-activity-type"
}
},
"mapping": [
{
"identity": "rim",
"map": "Act.code"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.purposeOfEvent"
},
{
"identity": "w3c.prov",
"map": "Activity.Activity"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Provenance.agent",
"path": "Provenance.agent",
"short": "Actor involved",
"definition": "An actor taking a role in an activity for which it can be assigned some degree of responsibility for the activity taking place.",
"comment": "Several agents may be associated (i.e. has some responsibility for an activity) with an activity and vice-versa.",
"requirements": "An agent can be a person, an organization, software, device, or other entities that may be ascribed responsibility.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": "./participation[isNormalParticipation()] OR ./outboundRelationship[isNormalActRelationship() and typeCode='DRIV']"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.agent"
},
{
"identity": "w3c.prov",
"map": "Agent"
},
{
"identity": "w5",
"map": "who"
}
]
},
{
"id": "Provenance.agent.id",
"path": "Provenance.agent.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Provenance.agent.extension",
"path": "Provenance.agent.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Provenance.agent.modifierExtension",
"path": "Provenance.agent.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Provenance.agent.role",
"path": "Provenance.agent.role",
"short": "What the agents role was",
"definition": "The function of the agent with respect to the activity. The security role enabling the agent with respect to the activity.",
"comment": "For example: author, performer, enterer, attester, doctor, nurse, clerk, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProvenanceAgentRole"
}
],
"strength": "extensible",
"description": "The role that a provenance agent played with respect to the activity.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/security-role-type"
}
},
"mapping": [
{
"identity": "rim",
"map": ".role and/or .typecode"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.agent.role"
},
{
"identity": "w3c.prov",
"map": "Agent.Attribution"
}
]
},
{
"id": "Provenance.agent.who[x]",
"path": "Provenance.agent.who[x]",
"short": "Who participated",
"definition": "The individual, device or organization that participated in the event.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Provenance.agent.onBehalfOf[x]",
"path": "Provenance.agent.onBehalfOf[x]",
"short": "Who the agent is representing",
"definition": "The individual, device, or organization for whom the change was made.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": "Person, Practitioner, Organization, Device :* .role [classCode = RoleClassMutualRelationship; role.code and * .scopes[Role](classCode=IDENT) and *.plays [Role.Code]"
}
]
},
{
"id": "Provenance.agent.relatedAgentType",
"path": "Provenance.agent.relatedAgentType",
"short": "Type of relationship between agents",
"definition": "The type of relationship between agents.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RelatedAgentType"
}
],
"strength": "example",
"description": "Type of relationship between two provenance agents.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-RoleLinkType"
}
},
"mapping": [
{
"identity": "rim",
"map": ".typeCode"
},
{
"identity": "w3c.prov",
"map": "type"
}
]
},
{
"id": "Provenance.entity",
"path": "Provenance.entity",
"short": "An entity used in this activity",
"definition": "An entity used in this activity.",
"comment": "Multiple userIds may be associated with the same Practitioner or other individual across various appearances, each with distinct privileges.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": "./subjectOf"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.entity"
},
{
"identity": "w3c.prov",
"map": "Entity"
}
]
},
{
"id": "Provenance.entity.id",
"path": "Provenance.entity.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Provenance.entity.extension",
"path": "Provenance.entity.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Provenance.entity.modifierExtension",
"path": "Provenance.entity.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Provenance.entity.role",
"path": "Provenance.entity.role",
"short": "derivation | revision | quotation | source | removal",
"definition": "How the entity was used during the activity.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProvenanceEntityRole"
}
],
"strength": "required",
"description": "How an entity was used in an activity.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/provenance-entity-role"
}
},
"mapping": [
{
"identity": "rim",
"map": "./typeCode"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.entity.lifecycle"
},
{
"identity": "w3c.prov",
"map": "Entity.role"
}
]
},
{
"id": "Provenance.entity.what[x]",
"path": "Provenance.entity.what[x]",
"short": "Identity of entity",
"definition": "Identity of the Entity used. May be a logical or physical uri and maybe absolute or relative.",
"comment": "Identity may be a reference to a resource or to something else, depending on the type.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
},
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "./text/reference"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.entity.reference"
},
{
"identity": "w3c.prov",
"map": "Entity.Identity"
}
]
},
{
"id": "Provenance.entity.agent",
"path": "Provenance.entity.agent",
"short": "Entity is attributed to this agent",
"definition": "The entity is attributed to an agent to express the agent's responsibility for that entity, possibly along with other agents. This description can be understood as shorthand for saying that the agent was responsible for the activity which generated the entity.",
"comment": "A usecase where one Provenance.entity.agent is used where the Entity that was used in the creation/updating of the Target, is not in the context of the same custodianship as the Target, and thus the meaning of Provenance.entity.agent is to say that the entity referenced is managed elsewhere and that this Agent provided access to it. This would be similar to where the Entity being referenced is managed outside FHIR, such as through HL7 v2, v3, or XDS. This might be where the Entity being referenced is managed in another FHIR resource server. Thus it explains the Provenance of that Entity's use in the context of this Provenance activity.",
"min": 0,
"max": "*",
"contentReference": "#Provenance.agent",
"mapping": [
{
"identity": "rim",
"map": "./author/role"
}
]
},
{
"id": "Provenance.signature",
"path": "Provenance.signature",
"short": "Signature on target",
"definition": "A digital signature on the target Reference(s). The signer should match a Provenance.agent. The purpose of the signature is indicated.",
"min": 0,
"max": "*",
"type": [
{
"code": "Signature"
}
],
"mapping": [
{
"identity": "rim",
"map": "./signatureText"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Provenance",
"path": "Provenance",
"short": "Who, What, When for a set of resources",
"definition": "Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies.",
"comment": "Some parties may be duplicated between the target resource and its provenance. For instance, the prescriber is usually (but not always) the author of the prescription resource. This resource is defined with close consideration for W3C Provenance.",
"alias": [
"History",
"Event",
"Activity"
],
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "ControlAct[isNormalAct() and subsumes(CACT, classCode) and moodCode=EVN]"
},
{
"identity": "w3c.prov",
"map": "Activity"
},
{
"identity": "w5",
"map": "infrastructure.information"
}
]
},
{
"id": "Provenance.target",
"path": "Provenance.target",
"short": "Target Reference(s) (usually version specific)",
"definition": "The Reference(s) that were generated or updated by the activity described in this resource. A provenance can point to more than one target if multiple resources were created/updated by the same activity.",
"comment": "Target references are usually version specific, but may not be, if a version has not been assigned or if the provenance information is part of the set of resources being maintained (i.e. a document). When using the RESTful API, the identity of the resource may not be known (especially not the version specific one); the client may either submit the resource first, and then the provenance, or it may submit both using a single transaction. See the notes on transaction for further discussion.",
"min": 1,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "./outboundRelationship[isNormalActRelationship() and typeCode=SUBJ]/target OR ./participation[isNormalParticipation() and typeCode=SBJ]/role OR ./participation[isNormalParticipation() and typeCode=SBJ]/role[isNormalRole()]/player"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.entity.reference"
},
{
"identity": "w3c.prov",
"map": "Entity Created/Updated"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Provenance.period",
"path": "Provenance.period",
"short": "When the activity occurred",
"definition": "The period during which the activity occurred.",
"comment": "The period can be a little arbitrary; where possible, the time should correspond to human assessment of the activity time.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": "./effectiveTime[type=IVL_TS]"
},
{
"identity": "w3c.prov",
"map": "Activity.startTime & Activity.endTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Provenance.recorded",
"path": "Provenance.recorded",
"short": "When the activity was recorded / updated",
"definition": "The instant of time at which the activity was recorded.",
"comment": "This can be a little different from the time stamp on the resource if there is a delay between recording the event and updating the provenance and target resource.",
"min": 1,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "unique(./participation[isNormalParticipation() and typeCode=AUT]/time[type=TS])"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.recorded"
},
{
"identity": "w3c.prov",
"map": "Activity.when"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "Provenance.policy",
"path": "Provenance.policy",
"short": "Policy or plan the activity was defined by",
"definition": "Policy or plan the activity was defined by. Typically, a single activity may have multiple applicable policy documents, such as patient consent, guarantor funding, etc.",
"comment": "For example: Where an OAuth token authorizes, the unique identifier from the OAuth token is placed into the policy element Where a policy engine (e.g. XACML) holds policy logic, the unique policy identifier is placed into the policy element.",
"min": 0,
"max": "*",
"type": [
{
"code": "uri"
}
],
"mapping": [
{
"identity": "rim",
"map": "./inboundRelationship[isNormalActRelationship() and typeCode=\"SUBJ\"]/source[isNormalAct and subsumes(POLICY, classCode) and moodCode=EVN]/text[typeCode='ED'/tel"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.agent.policy"
}
]
},
{
"id": "Provenance.location",
"path": "Provenance.location",
"short": "Where the activity occurred, if relevant",
"definition": "Where the activity occurred, if relevant.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"mapping": [
{
"identity": "rim",
"map": "unique(./participation[isNormalParticipation() and typeCode=LOC]/role[isNormalRole() and subsumes(SDLOC, classCode)]/player[isNormalEntity and classCode=\"LOC\" and determinerCode=\"INST\"]"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.agent.location"
},
{
"identity": "w3c.prov",
"map": "Activity.location"
},
{
"identity": "w5",
"map": "where"
}
]
},
{
"id": "Provenance.reason",
"path": "Provenance.reason",
"short": "Reason the activity is occurring",
"definition": "The reason that the activity was taking place.",
"min": 0,
"max": "*",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProvenanceReason"
}
],
"strength": "extensible",
"description": "The reason the activity took place.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-PurposeOfUse"
}
},
"mapping": [
{
"identity": "rim",
"map": "unique(./reasonCode)"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.purposeOfEvent"
},
{
"identity": "w3c.prov",
"map": "Activity.Activity"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Provenance.activity",
"path": "Provenance.activity",
"short": "Activity that occurred",
"definition": "An activity is something that occurs over a period of time and acts upon or with entities; it may include consuming, processing, transforming, modifying, relocating, using, or generating entities.",
"min": 0,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProvenanceActivity"
}
],
"strength": "extensible",
"description": "The activity that took place.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/provenance-activity-type"
}
},
"mapping": [
{
"identity": "rim",
"map": "Act.code"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.purposeOfEvent"
},
{
"identity": "w3c.prov",
"map": "Activity.Activity"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Provenance.agent",
"path": "Provenance.agent",
"short": "Actor involved",
"definition": "An actor taking a role in an activity for which it can be assigned some degree of responsibility for the activity taking place.",
"comment": "Several agents may be associated (i.e. has some responsibility for an activity) with an activity and vice-versa.",
"requirements": "An agent can be a person, an organization, software, device, or other entities that may be ascribed responsibility.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": "./participation[isNormalParticipation()] OR ./outboundRelationship[isNormalActRelationship() and typeCode='DRIV']"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.agent"
},
{
"identity": "w3c.prov",
"map": "Agent"
},
{
"identity": "w5",
"map": "who"
}
]
},
{
"id": "Provenance.agent.role",
"path": "Provenance.agent.role",
"short": "What the agents role was",
"definition": "The function of the agent with respect to the activity. The security role enabling the agent with respect to the activity.",
"comment": "For example: author, performer, enterer, attester, doctor, nurse, clerk, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProvenanceAgentRole"
}
],
"strength": "extensible",
"description": "The role that a provenance agent played with respect to the activity.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/security-role-type"
}
},
"mapping": [
{
"identity": "rim",
"map": ".role and/or .typecode"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.agent.role"
},
{
"identity": "w3c.prov",
"map": "Agent.Attribution"
}
]
},
{
"id": "Provenance.agent.who[x]",
"path": "Provenance.agent.who[x]",
"short": "Who participated",
"definition": "The individual, device or organization that participated in the event.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Provenance.agent.onBehalfOf[x]",
"path": "Provenance.agent.onBehalfOf[x]",
"short": "Who the agent is representing",
"definition": "The individual, device, or organization for whom the change was made.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": "Person, Practitioner, Organization, Device :* .role [classCode = RoleClassMutualRelationship; role.code and * .scopes[Role](classCode=IDENT) and *.plays [Role.Code]"
}
]
},
{
"id": "Provenance.agent.relatedAgentType",
"path": "Provenance.agent.relatedAgentType",
"short": "Type of relationship between agents",
"definition": "The type of relationship between agents.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RelatedAgentType"
}
],
"strength": "example",
"description": "Type of relationship between two provenance agents.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v3-RoleLinkType"
}
},
"mapping": [
{
"identity": "rim",
"map": ".typeCode"
},
{
"identity": "w3c.prov",
"map": "type"
}
]
},
{
"id": "Provenance.entity",
"path": "Provenance.entity",
"short": "An entity used in this activity",
"definition": "An entity used in this activity.",
"comment": "Multiple userIds may be associated with the same Practitioner or other individual across various appearances, each with distinct privileges.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": "./subjectOf"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.entity"
},
{
"identity": "w3c.prov",
"map": "Entity"
}
]
},
{
"id": "Provenance.entity.role",
"path": "Provenance.entity.role",
"short": "derivation | revision | quotation | source | removal",
"definition": "How the entity was used during the activity.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ProvenanceEntityRole"
}
],
"strength": "required",
"description": "How an entity was used in an activity.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/provenance-entity-role"
}
},
"mapping": [
{
"identity": "rim",
"map": "./typeCode"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.entity.lifecycle"
},
{
"identity": "w3c.prov",
"map": "Entity.role"
}
]
},
{
"id": "Provenance.entity.what[x]",
"path": "Provenance.entity.what[x]",
"short": "Identity of entity",
"definition": "Identity of the Entity used. May be a logical or physical uri and maybe absolute or relative.",
"comment": "Identity may be a reference to a resource or to something else, depending on the type.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
},
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "./text/reference"
},
{
"identity": "fhirauditevent",
"map": "AuditEvent.entity.reference"
},
{
"identity": "w3c.prov",
"map": "Entity.Identity"
}
]
},
{
"id": "Provenance.entity.agent",
"path": "Provenance.entity.agent",
"short": "Entity is attributed to this agent",
"definition": "The entity is attributed to an agent to express the agent's responsibility for that entity, possibly along with other agents. This description can be understood as shorthand for saying that the agent was responsible for the activity which generated the entity.",
"comment": "A usecase where one Provenance.entity.agent is used where the Entity that was used in the creation/updating of the Target, is not in the context of the same custodianship as the Target, and thus the meaning of Provenance.entity.agent is to say that the entity referenced is managed elsewhere and that this Agent provided access to it. This would be similar to where the Entity being referenced is managed outside FHIR, such as through HL7 v2, v3, or XDS. This might be where the Entity being referenced is managed in another FHIR resource server. Thus it explains the Provenance of that Entity's use in the context of this Provenance activity.",
"min": 0,
"max": "*",
"contentReference": "#Provenance.agent",
"mapping": [
{
"identity": "rim",
"map": "./author/role"
}
]
},
{
"id": "Provenance.signature",
"path": "Provenance.signature",
"short": "Signature on target",
"definition": "A digital signature on the target Reference(s). The signer should match a Provenance.agent. The purpose of the signature is indicated.",
"min": 0,
"max": "*",
"type": [
{
"code": "Signature"
}
],
"mapping": [
{
"identity": "rim",
"map": "./signatureText"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Questionnaire",
"resource": {
"resourceType": "StructureDefinition",
"id": "Questionnaire",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Questionnaire I DomainResource A structured set of questions
+ The link ids for groups and questions must be unique within the questionnaire
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension url Σ 0..1 uri Logical URI to reference this questionnaire (globally unique) identifier Σ 0..* Identifier Additional identifier for the questionnaire
version Σ 0..1 string Business version of the questionnaire name Σ 0..1 string Name for this questionnaire (computer friendly) title Σ 0..1 string Name for this questionnaire (human friendly) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) experimental ?!Σ 0..1 boolean For testing purposes, not real usage date Σ 0..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) description 0..1 markdown Natural language description of the questionnaire purpose 0..1 markdown Why this questionnaire is defined approvalDate 0..1 date When the questionnaire was approved by publisher lastReviewDate 0..1 date When the questionnaire was last reviewed effectivePeriod Σ 0..1 Period When the questionnaire is expected to be used useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for questionnaire (if applicable)
Jurisdiction ValueSet (Extensible)
contact Σ 0..* ContactDetail Contact details for the publisher
copyright 0..1 markdown Use and/or publishing restrictions code Σ 0..* Coding Concept that represents the overall questionnaire
Questionnaire Question Codes (Example)
subjectType Σ 0..* code Resource that can be subject of QuestionnaireResponse
ResourceType (Required)
item I 0..* BackboneElement Questions and sections within the Questionnaire
+ Read-only can't be specified for "display" items
+ Default values can't be specified for groups or display items
+ Required and repeat aren't permitted for display items
+ Only 'choice' items can have options
+ A question cannot have both option and options
+ Display items cannot have a "code" asserted
+ Maximum length can only be declared for simple question types
+ Group items must have nested items, display items cannot have nested items
linkId 1..1 string Unique id for item in questionnaire definition 0..1 uri ElementDefinition - details for the item code ΣI 0..* Coding Corresponding concept for this item in a terminology
Questionnaire Question Codes (Example)
prefix 0..1 string E.g. "1(a)", "2.5.3" text Σ 0..1 string Primary text for the item type 1..1 code group | display | boolean | decimal | integer | date | dateTime +
QuestionnaireItemType (Required) enableWhen ?!ΣI 0..* BackboneElement Only allow data when
+ enableWhen must contain either a 'answer' or a 'hasAnswer' element
question 1..1 string Question that determines whether item is enabled hasAnswer I 0..1 boolean Enable when answered or not answer[x] I 0..1 Value question must have
Questionnaire Answer Codes (Example) answerBoolean boolean answerDecimal decimal answerInteger integer answerDate date answerDateTime dateTime answerTime time answerString string answerUri uri answerAttachment Attachment answerCoding Coding answerQuantity Quantity answerReference Reference(Any) required I 0..1 boolean Whether the item must be included in data results repeats I 0..1 boolean Whether the item may repeat readOnly I 0..1 boolean Don't allow human editing maxLength I 0..1 integer No more than this many characters options I 0..1 Reference(ValueSet) Valueset containing permitted answers option I 0..* BackboneElement Permitted answer
value[x] 1..1 Answer value
Questionnaire Answer Codes (Example) valueInteger integer valueDate date valueTime time valueString string valueCoding Coding initial[x] I 0..1 Default value when item is first rendered
Questionnaire Answer Codes (Example) initialBoolean boolean initialDecimal decimal initialInteger integer initialDate date initialDateTime dateTime initialTime time initialString string initialUri uri initialAttachment Attachment initialCoding Coding initialQuantity Quantity initialReference Reference(Any) item I 0..* see item Nested questionnaire items
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Questionnaire",
"name": "Questionnaire",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Questionnaire Resource",
"purpose": "To support structured, hierarchical registration of data gathered using digital forms and other questionnaires. Questionnaires provide greater control over presentation and allow capture of data in a domain-independent way (i.e. capturing information that would otherwise require multiple distinct types of resources).",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "objimpl",
"uri": "http://hl7.org/fhir/object-implementation",
"name": "Object Implementation Information"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Questionnaire",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"_baseDefinition": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-codegen-super",
"valueString": "MetadataResource"
}
]
},
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Questionnaire",
"path": "Questionnaire",
"short": "A structured set of questions",
"definition": "A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection.",
"alias": [
"Form",
"CRF",
"Survey"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "que-2",
"severity": "error",
"human": "The link ids for groups and questions must be unique within the questionnaire",
"expression": "descendants().linkId.isDistinct()",
"xpath": "count(descendant::f:linkId/@value)=count(distinct-values(descendant::f:linkId/@value))"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "Observation[moodCode=DEF]"
},
{
"identity": "w5",
"map": "infrastructure.information"
}
]
},
{
"id": "Questionnaire.id",
"path": "Questionnaire.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Questionnaire.meta",
"path": "Questionnaire.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Questionnaire.implicitRules",
"path": "Questionnaire.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Questionnaire.language",
"path": "Questionnaire.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Questionnaire.text",
"path": "Questionnaire.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Questionnaire.contained",
"path": "Questionnaire.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Questionnaire.extension",
"path": "Questionnaire.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Questionnaire.modifierExtension",
"path": "Questionnaire.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Questionnaire.url",
"path": "Questionnaire.url",
"short": "Logical URI to reference this questionnaire (globally unique)",
"definition": "An absolute URI that is used to identify this questionnaire when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this questionnaire is (or will be) published. The URL SHOULD include the major version of the questionnaire. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "… This is the id that will be used to link a QuestionnaireResponse to the Questionnaire the response is for.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".identifier[scope=BUSN;reliability=ISS]"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Questionnaire.identifier",
"path": "Questionnaire.identifier",
"short": "Additional identifier for the questionnaire",
"definition": "A formal identifier that is used to identify this questionnaire when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this questionnaire outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".identifier"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Questionnaire.version",
"path": "Questionnaire.version",
"short": "Business version of the questionnaire",
"definition": "The identifier that is used to identify this version of the questionnaire when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the questionnaire author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different questionnaire instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the questionnaire with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A (to add?)"
},
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "Questionnaire.name",
"path": "Questionnaire.name",
"short": "Name for this questionnaire (computer friendly)",
"definition": "A natural language name identifying the questionnaire. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Questionnaire.title",
"path": "Questionnaire.title",
"short": "Name for this questionnaire (human friendly)",
"definition": "A short, descriptive, user-friendly title for the questionnaire.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".title"
}
]
},
{
"id": "Questionnaire.status",
"path": "Questionnaire.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this questionnaire. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of questionnaires that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired questionnaire without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Questionnaire.experimental",
"path": "Questionnaire.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this questionnaire is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of questionnaire that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental questionnaire in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level questionnaire.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Questionnaire.date",
"path": "Questionnaire.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the questionnaire was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the questionnaire changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the questionnaire. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "Questionnaire.publisher",
"path": "Questionnaire.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the questionnaire.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the questionnaire is the organization or individual primarily responsible for the maintenance and upkeep of the questionnaire. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the questionnaire. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the questionnaire. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "Questionnaire.description",
"path": "Questionnaire.description",
"short": "Natural language description of the questionnaire",
"definition": "A free text natural language description of the questionnaire from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the questionnaire was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the questionnaire as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "Questionnaire.purpose",
"path": "Questionnaire.purpose",
"short": "Why this questionnaire is defined",
"definition": "Explaination of why this questionnaire is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the questionnaire Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this questionnaire.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "rim",
"map": ".reasonCode.text"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Questionnaire.approvalDate",
"path": "Questionnaire.approvalDate",
"short": "When the questionnaire was approved by publisher",
"definition": "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.",
"comment": "The 'date' element may be more recent than the approval date because of minor changes / editorial corrections.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"SUBJ\"].act[classCode=CACT;moodCode=EVN;code=\"approval\"].effectiveTime"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "Questionnaire.lastReviewDate",
"path": "Questionnaire.lastReviewDate",
"short": "When the questionnaire was last reviewed",
"definition": "The date on which the resource content was last reviewed. Review happens periodically after approval, but doesn't change the original approval date.",
"comment": "If specified, this is usually after the approval date.",
"requirements": "Gives a sense of how \"current\" the content is. Resources that have not been reviewed in a long time may have a risk of being less appropriate/relevant.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"SUBJ\"; subsetCode=\"RECENT\"].act[classCode=CACT;moodCode=EVN;code=\"review\"].effectiveTime"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "Questionnaire.effectivePeriod",
"path": "Questionnaire.effectivePeriod",
"short": "When the questionnaire is expected to be used",
"definition": "The period during which the questionnaire content was or is planned to be in active use.",
"comment": "The effective period for a questionnaire determines when the content is applicable for usage and is independent of publication and review dates. For example, a measure intended to be used for the year 2016 might be published in 2015.",
"requirements": "Allows establishing a transition before a resource comes into effect and also allows for a sunsetting process when new versions of a the questionnaire are or are expected to be used instead.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A (to add?)"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "Questionnaire.useContext",
"path": "Questionnaire.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate questionnaire instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A (to add?)"
}
]
},
{
"id": "Questionnaire.jurisdiction",
"path": "Questionnaire.jurisdiction",
"short": "Intended jurisdiction for questionnaire (if applicable)",
"definition": "A legal or geographic region in which the questionnaire is intended to be used.",
"comment": "It may be possible for the questionnaire to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A (to add?)"
}
]
},
{
"id": "Questionnaire.contact",
"path": "Questionnaire.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=CALLBCK].role"
}
]
},
{
"id": "Questionnaire.copyright",
"path": "Questionnaire.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the questionnaire and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the questionnaire.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the questionnaire and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A (to add?)"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "Questionnaire.code",
"path": "Questionnaire.code",
"short": "Concept that represents the overall questionnaire",
"definition": "An identifier for this question or group of questions in a particular terminology such as LOINC.",
"requirements": "Allows linking of the complete Questionnaire resources to formal terminologies. It's common for \"panels\" of questions to be identified by a code.",
"min": 0,
"max": "*",
"type": [
{
"code": "Coding"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireConcept"
}
],
"strength": "example",
"description": "Codes for questionnaires, groups and individual questions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-questions"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "Questionnaire.subjectType",
"path": "Questionnaire.subjectType",
"short": "Resource that can be subject of QuestionnaireResponse",
"definition": "The types of subjects that can be the subject of responses created for the questionnaire.",
"comment": "If none are specified, then the subject is unlimited.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResourceType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "One of the resource types defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/resource-types"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=META].target[classCode=OBS, moodCode=DEFN, isCriterion=true].participation.role.classCode"
}
]
},
{
"id": "Questionnaire.item",
"path": "Questionnaire.item",
"short": "Questions and sections within the Questionnaire",
"definition": "A particular question, question grouping or display text that is part of the questionnaire.",
"comment": "The content of the questionnaire is constructed from an ordered, hierarchical collection of items.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"que-3"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "que-9",
"severity": "error",
"human": "Read-only can't be specified for \"display\" items",
"expression": "type!='display' or readOnly.empty()",
"xpath": "not(f:type/@value='display' and f:readOnly)"
},
{
"key": "que-8",
"severity": "error",
"human": "Default values can't be specified for groups or display items",
"expression": "(type!='group' and type!='display') or initial.empty()",
"xpath": "not(f:type/@value=('group', 'display') and f:*[starts-with(local-name(.), 'initial')])"
},
{
"key": "que-6",
"severity": "error",
"human": "Required and repeat aren't permitted for display items",
"expression": "type!='display' or (required.empty() and repeats.empty())",
"xpath": "not(f:type/@value='display' and (f:required or f:repeats))"
},
{
"key": "que-5",
"severity": "error",
"human": "Only 'choice' items can have options",
"expression": "(type ='choice' or type = 'open-choice') or (options.empty() and option.empty())",
"xpath": "f:type/@value=('choice','open-choice') or not(f:option or f:options)"
},
{
"key": "que-4",
"severity": "error",
"human": "A question cannot have both option and options",
"expression": "option.empty() or options.empty()",
"xpath": "not(f:options and f:option)"
},
{
"key": "que-3",
"severity": "error",
"human": "Display items cannot have a \"code\" asserted",
"expression": "type!='display' or code.empty()",
"xpath": "not(f:type/@value='display' and f:code)"
},
{
"key": "que-10",
"severity": "error",
"human": "Maximum length can only be declared for simple question types",
"expression": "(type in ('boolean' | 'decimal' | 'integer' | 'string' | 'text' | 'url')) or maxLength.empty()",
"xpath": "f:type/@value=('boolean', 'decimal', 'integer', 'open-choice', 'string', 'text', 'url') or not(f:maxLength)"
},
{
"key": "que-1",
"severity": "error",
"human": "Group items must have nested items, display items cannot have nested items",
"expression": "(type='group' implies item.empty().not()) and (type.trace('type')='display' implies item.trace('item').empty())",
"xpath": "not((f:type/@value='group' and not(f:item)) or (f:type/@value='display' and f:item))"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=OBS, moodCode=DEF]"
}
]
},
{
"id": "Questionnaire.item.id",
"path": "Questionnaire.item.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Questionnaire.item.extension",
"path": "Questionnaire.item.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Questionnaire.item.modifierExtension",
"path": "Questionnaire.item.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Questionnaire.item.linkId",
"path": "Questionnaire.item.linkId",
"short": "Unique id for item in questionnaire",
"definition": "An identifier that is unique within the Questionnaire allowing linkage to the equivalent item in a QuestionnaireResponse resource.",
"comment": "This ''can'' be a meaningful identifier (e.g. a LOINC code) but is not intended to have any meaning. GUIDs or sequential numbers are appropriate here.",
"requirements": "[QuestionnaireResponse](questionnaireresponse.html#) does not require omitted items to be included and may have some items that repeat, so linkage based on position alone is not sufficient.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "Questionnaire.item.definition",
"path": "Questionnaire.item.definition",
"short": "ElementDefinition - details for the item",
"definition": "A reference to an [ElementDefinition](elementdefinition.html) that provides the details for the item. If a definition is provided, then the following element values can be inferred from the definition: \n\n* code (ElementDefinition.code)\n* type (ElementDefinition.type)\n* required (ElementDefinition.min)\n* repeats (ElementDefinition.max)\n* maxLength (ElementDefinition.maxLength)\n* options (ElementDefinition.binding)\n\nAny information provided in these elements on a Questionnaire Item overrides the information from the definition.",
"comment": "the URI refers to an ElementDefinition in either a [StructureDefinition](structuredefinition.html#) or a [DataElement](dataelement.html#), and always starts with the canonical URL for the target resource. When referring to a StructureDefinition, a fragment identifier is used to specify the element definition by its id [Element.id](element-definitions.html#Element.id). E.g. http://hl7.org/fhir/StructureDefinition/Observation#Observation.value[x]. In the absence of a fragment identifier, the first/root element definition in the target is the matching element definition. Note that [LOINC codes](loinc.html#dataelements) implicitly define DataElement resources.",
"requirements": "A common pattern is to define a set of data elements and then build multiple questionnaires for different circumstances to gather the data. This element provides traceability to the common definition and allows the content for the question to come from the underlying definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=INST].target[classCode=OBS, moodCode=DEF]"
}
]
},
{
"id": "Questionnaire.item.code",
"path": "Questionnaire.item.code",
"short": "Corresponding concept for this item in a terminology",
"definition": "A terminology code that corresponds to this group or question (e.g. a code from LOINC, which defines many questions and answers).",
"comment": "The value may come from the ElementDefinition referred to by .definition.",
"requirements": "Allows linking of groups of questions to formal terminologies.",
"min": 0,
"max": "*",
"type": [
{
"code": "Coding"
}
],
"condition": [
"que-3"
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireConcept"
}
],
"strength": "example",
"description": "Codes for questionnaires, groups and individual questions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-questions"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "Questionnaire.item.prefix",
"path": "Questionnaire.item.prefix",
"short": "E.g. \"1(a)\", \"2.5.3\"",
"definition": "A short label for a particular group, question or set of display text within the questionnaire used for reference by the individual completing the questionnaire.",
"comment": "These are generally unique within a questionnaire, though this is not guaranteed. Some questionnaires may have multiple questions with the same label with logic to control which gets exposed.\n\nTypically these won't be used for \"display\" items, though such use is not prohibited.\n\nSystems SHOULD NOT generate their own prefixes if prefixes are defined for any items within a Questionnaire.",
"requirements": "Separating the label from the question text allows improved rendering. Also, instructions will often refer to specific prefixes, so there's a need for the questionnaire design to have control over what labels are used.",
"alias": [
"label"
],
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "Not supported"
}
]
},
{
"id": "Questionnaire.item.text",
"path": "Questionnaire.item.text",
"short": "Primary text for the item",
"definition": "The name of a section, the text of a question or text content for a display item.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "Questionnaire.item.type",
"path": "Questionnaire.item.type",
"short": "group | display | boolean | decimal | integer | date | dateTime +",
"definition": "The type of questionnaire item this is - whether text for display, a grouping of other items or a particular type of data to be captured (string, integer, coded choice, etc.).",
"comment": "Additional constraints on the type of answer can be conveyed by extensions. The value may come from the ElementDefinition referred to by .definition.",
"requirements": "Defines the format in which the user is to be prompted for the answer.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireItemType"
}
],
"strength": "required",
"description": "Distinguishes groups from questions and display text and indicates data type for questions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/item-type"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.enableWhen",
"path": "Questionnaire.item.enableWhen",
"short": "Only allow data when",
"definition": "A constraint indicating that this item should only be enabled (displayed/allow answers to be captured) when the specified condition is true.",
"comment": "If multiple repetitions of this extension are present, the item should be enabled when the condition for *any* of the repetitions is true. I.e. treat \"enableWhen\"s as being joined by an \"or\" clause.\n\nThis element is a modifier because if enableWhen is present for an item, \"required\" is ignored unless one of the enableWhen conditions is met.",
"requirements": "Allows questionnaires to adapt based on answers to other questions. E.g. If physical gender is specified as a male, no need to capture pregnancy history. Also allows conditional display of instructions or groups of questions.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "que-7",
"severity": "error",
"human": "enableWhen must contain either a 'answer' or a 'hasAnswer' element",
"expression": "hasAnswer.exists() xor answer.exists()",
"xpath": "count(f:*[starts-with(local-name(.), 'answer')]|self::f:hasAnswer) = 1"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.enableWhen.id",
"path": "Questionnaire.item.enableWhen.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Questionnaire.item.enableWhen.extension",
"path": "Questionnaire.item.enableWhen.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Questionnaire.item.enableWhen.modifierExtension",
"path": "Questionnaire.item.enableWhen.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Questionnaire.item.enableWhen.question",
"path": "Questionnaire.item.enableWhen.question",
"short": "Question that determines whether item is enabled",
"definition": "The linkId for the question whose answer (or lack of answer) governs whether this item is enabled.",
"comment": "If multiple question occurrences are present for the same question (same linkId), then this refers to the nearest question occurrence reachable by tracing first the \"ancestor\" axis and then the \"preceding\" axis and then the \"following\" axis.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.enableWhen.hasAnswer",
"path": "Questionnaire.item.enableWhen.hasAnswer",
"short": "Enable when answered or not",
"definition": "An indication that this item should be enabled only if the specified question is answered (hasAnswer=true) or not answered (hasAnswer=false).",
"comment": "If answered=false and answer values are also provided, then they are treated as \"or\". I.e. \"Enable if the question is unanswered or the answer is one of the specified values\". If answered=true and answers are present, one of the specified answers must be met. (So there's little reason to specify answered=true if answers are present.).",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"condition": [
"que-7"
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.enableWhen.answer[x]",
"path": "Questionnaire.item.enableWhen.answer[x]",
"short": "Value question must have",
"definition": "An answer that the referenced question must match in order for the item to be enabled.",
"comment": "Multiple answers are treated as \"or\". E.g. Enable if question 1 = A, C or E. \n\nComponents not specified in the answer do not need to match. For example, if enableWhen specifies code + system for a Coding, it is ok if the answer has a \"display\" element. I.e. treat the answer as a 'pattern'.\n\nThe dataType of this element must be the same as the data type of the question being referenced.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "decimal"
},
{
"code": "integer"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "time"
},
{
"code": "string"
},
{
"code": "uri"
},
{
"code": "Attachment"
},
{
"code": "Coding"
},
{
"code": "Quantity"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"condition": [
"que-7"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireQuestionOption2"
}
],
"strength": "example",
"description": "Allowed values to answer questions.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-answers"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.required",
"path": "Questionnaire.item.required",
"short": "Whether the item must be included in data results",
"definition": "An indication, if true, that the item must be present in a \"completed\" QuestionnaireResponse. If false, the item may be skipped when answering the questionnaire.",
"comment": "Questionnaire.item.required only has meaning for elements that are conditionally enabled with enableWhen if the condition evaluates to true. If an item that contains other items is marked as required, that does not automatically make the contained elements required (though required groups must contain at least one child element). The value may come from the ElementDefinition referred to by .definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false,
"condition": [
"que-6"
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.repeats",
"path": "Questionnaire.item.repeats",
"short": "Whether the item may repeat",
"definition": "An indication, if true, that the item may occur multiple times in the response, collecting multiple answers answers for questions or multiple sets of answers for groups.",
"comment": "If a question is marked as repeats=true, then multiple answers can be provided for the question in the corresponding QuestionnaireResponse. When rendering the questionnaire, it is up to the rendering software whether to render the question text for each answer repetition or to simply list each of the answers beneath the question. (Which is most appropriate visually may depend on the type of answer as well as whether there are nested items.). The value may come from the ElementDefinition referred to by .definition.",
"requirements": "Items may be used to create set of (related) questions that can be repeated to give multiple answers to such a set.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false,
"condition": [
"que-6"
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.readOnly",
"path": "Questionnaire.item.readOnly",
"short": "Don't allow human editing",
"definition": "An indication, when true, that the value cannot be changed by a human respondent to the Questionnaire.",
"comment": "The value of readOnly elements can be established by asserting extensions for defaultValues, linkages that support pre-population and/or extensions that support calculation based on other answers.",
"requirements": "Allows certain information to be phrased (and rendered) as a question and an answer, while keeping users from changing it. May also be useful for preventing changes to pre-populated portions of a questionnaire, for calculated values, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"condition": [
"que-9"
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.maxLength",
"path": "Questionnaire.item.maxLength",
"short": "No more than this many characters",
"definition": "The maximum number of characters that are permitted in the answer to be considered a \"valid\" QuestionnaireResponse.",
"comment": "For base64binary, reflects the number of characters representing the encoded data, not the number of bytes of the binary data. The value may come from the ElementDefinition referred to by .definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"condition": [
"que-10"
],
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.options",
"path": "Questionnaire.item.options",
"short": "Valueset containing permitted answers",
"definition": "A reference to a value set containing a list of codes representing permitted answers for a \"choice\" or \"open-choice\" question.",
"comment": "LOINC defines many useful value sets for questionnaire responses. See [LOINC Answer Lists](loinc.html#alist). The value may come from the ElementDefinition referred to by .definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ValueSet"
}
],
"condition": [
"que-4",
"que-5"
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.option",
"path": "Questionnaire.item.option",
"short": "Permitted answer",
"definition": "One of the permitted answers for a \"choice\" or \"open-choice\" question.",
"comment": "This element can be used when the value set machinery of options is deemed too cumbersome or when there's a need to capture options that are not codes.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"que-4",
"que-5"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.option.id",
"path": "Questionnaire.item.option.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Questionnaire.item.option.extension",
"path": "Questionnaire.item.option.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Questionnaire.item.option.modifierExtension",
"path": "Questionnaire.item.option.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Questionnaire.item.option.value[x]",
"path": "Questionnaire.item.option.value[x]",
"short": "Answer value",
"definition": "A potential answer that's allowed as the answer to this question.",
"comment": "The data type of the value must agree with the item.type.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
},
{
"code": "date"
},
{
"code": "time"
},
{
"code": "string"
},
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireQuestionOption"
}
],
"strength": "example",
"description": "Allowed values to answer questions.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-answers"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.initial[x]",
"path": "Questionnaire.item.initial[x]",
"short": "Default value when item is first rendered",
"definition": "The value that should be defaulted when initially rendering the questionnaire for user input.",
"comment": "The user is allowed to change the value and override the default (unless marked as read-only). If the user doesn't change the value, then this initial value will be persisted when the QuestionnaireResponse is initially created. Note that default values can influence results.\n\nThe data type of initial[x] must agree with the item.type.",
"requirements": "In some workflows, having defaults saves time.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "decimal"
},
{
"code": "integer"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "time"
},
{
"code": "string"
},
{
"code": "uri"
},
{
"code": "Attachment"
},
{
"code": "Coding"
},
{
"code": "Quantity"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"condition": [
"que-8"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireQuestionOption2"
}
],
"strength": "example",
"description": "Allowed values to answer questions.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-answers"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.item",
"path": "Questionnaire.item.item",
"short": "Nested questionnaire items",
"definition": "Text, questions and other groups to be nested beneath a question or group.",
"comment": "There is no specified limit to the depth of nesting. However, Questionnaire authors are encouraged to consider the impact on the user and user interface of overly deep nesting.",
"requirements": "Reports can consist of complex nested groups.",
"min": 0,
"max": "*",
"contentReference": "#Questionnaire.item",
"condition": [
"que-1"
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Questionnaire",
"path": "Questionnaire",
"short": "A structured set of questions",
"definition": "A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection.",
"alias": [
"Form",
"CRF",
"Survey"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "que-2",
"severity": "error",
"human": "The link ids for groups and questions must be unique within the questionnaire",
"expression": "descendants().linkId.isDistinct()",
"xpath": "count(descendant::f:linkId/@value)=count(distinct-values(descendant::f:linkId/@value))"
}
],
"mapping": [
{
"identity": "rim",
"map": "Observation[moodCode=DEF]"
},
{
"identity": "w5",
"map": "infrastructure.information"
}
]
},
{
"id": "Questionnaire.url",
"path": "Questionnaire.url",
"short": "Logical URI to reference this questionnaire (globally unique)",
"definition": "An absolute URI that is used to identify this questionnaire when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this questionnaire is (or will be) published. The URL SHOULD include the major version of the questionnaire. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "… This is the id that will be used to link a QuestionnaireResponse to the Questionnaire the response is for.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".identifier[scope=BUSN;reliability=ISS]"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Questionnaire.identifier",
"path": "Questionnaire.identifier",
"short": "Additional identifier for the questionnaire",
"definition": "A formal identifier that is used to identify this questionnaire when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this questionnaire outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".identifier"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Questionnaire.version",
"path": "Questionnaire.version",
"short": "Business version of the questionnaire",
"definition": "The identifier that is used to identify this version of the questionnaire when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the questionnaire author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different questionnaire instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the questionnaire with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A (to add?)"
},
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "Questionnaire.name",
"path": "Questionnaire.name",
"short": "Name for this questionnaire (computer friendly)",
"definition": "A natural language name identifying the questionnaire. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Questionnaire.title",
"path": "Questionnaire.title",
"short": "Name for this questionnaire (human friendly)",
"definition": "A short, descriptive, user-friendly title for the questionnaire.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".title"
}
]
},
{
"id": "Questionnaire.status",
"path": "Questionnaire.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this questionnaire. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of questionnaires that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired questionnaire without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Questionnaire.experimental",
"path": "Questionnaire.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this questionnaire is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of questionnaire that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental questionnaire in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level questionnaire.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Questionnaire.date",
"path": "Questionnaire.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the questionnaire was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the questionnaire changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the questionnaire. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "Questionnaire.publisher",
"path": "Questionnaire.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the questionnaire.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the questionnaire is the organization or individual primarily responsible for the maintenance and upkeep of the questionnaire. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the questionnaire. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the questionnaire. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "Questionnaire.description",
"path": "Questionnaire.description",
"short": "Natural language description of the questionnaire",
"definition": "A free text natural language description of the questionnaire from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the questionnaire was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the questionnaire as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "Questionnaire.purpose",
"path": "Questionnaire.purpose",
"short": "Why this questionnaire is defined",
"definition": "Explaination of why this questionnaire is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the questionnaire Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this questionnaire.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "rim",
"map": ".reasonCode.text"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Questionnaire.approvalDate",
"path": "Questionnaire.approvalDate",
"short": "When the questionnaire was approved by publisher",
"definition": "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.",
"comment": "The 'date' element may be more recent than the approval date because of minor changes / editorial corrections.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"SUBJ\"].act[classCode=CACT;moodCode=EVN;code=\"approval\"].effectiveTime"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "Questionnaire.lastReviewDate",
"path": "Questionnaire.lastReviewDate",
"short": "When the questionnaire was last reviewed",
"definition": "The date on which the resource content was last reviewed. Review happens periodically after approval, but doesn't change the original approval date.",
"comment": "If specified, this is usually after the approval date.",
"requirements": "Gives a sense of how \"current\" the content is. Resources that have not been reviewed in a long time may have a risk of being less appropriate/relevant.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=\"SUBJ\"; subsetCode=\"RECENT\"].act[classCode=CACT;moodCode=EVN;code=\"review\"].effectiveTime"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "Questionnaire.effectivePeriod",
"path": "Questionnaire.effectivePeriod",
"short": "When the questionnaire is expected to be used",
"definition": "The period during which the questionnaire content was or is planned to be in active use.",
"comment": "The effective period for a questionnaire determines when the content is applicable for usage and is independent of publication and review dates. For example, a measure intended to be used for the year 2016 might be published in 2015.",
"requirements": "Allows establishing a transition before a resource comes into effect and also allows for a sunsetting process when new versions of a the questionnaire are or are expected to be used instead.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A (to add?)"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "Questionnaire.useContext",
"path": "Questionnaire.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate questionnaire instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A (to add?)"
}
]
},
{
"id": "Questionnaire.jurisdiction",
"path": "Questionnaire.jurisdiction",
"short": "Intended jurisdiction for questionnaire (if applicable)",
"definition": "A legal or geographic region in which the questionnaire is intended to be used.",
"comment": "It may be possible for the questionnaire to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A (to add?)"
}
]
},
{
"id": "Questionnaire.contact",
"path": "Questionnaire.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=CALLBCK].role"
}
]
},
{
"id": "Questionnaire.copyright",
"path": "Questionnaire.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the questionnaire and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the questionnaire.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the questionnaire and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A (to add?)"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "Questionnaire.code",
"path": "Questionnaire.code",
"short": "Concept that represents the overall questionnaire",
"definition": "An identifier for this question or group of questions in a particular terminology such as LOINC.",
"requirements": "Allows linking of the complete Questionnaire resources to formal terminologies. It's common for \"panels\" of questions to be identified by a code.",
"min": 0,
"max": "*",
"type": [
{
"code": "Coding"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireConcept"
}
],
"strength": "example",
"description": "Codes for questionnaires, groups and individual questions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-questions"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "Questionnaire.subjectType",
"path": "Questionnaire.subjectType",
"short": "Resource that can be subject of QuestionnaireResponse",
"definition": "The types of subjects that can be the subject of responses created for the questionnaire.",
"comment": "If none are specified, then the subject is unlimited.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResourceType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "One of the resource types defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/resource-types"
}
},
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=META].target[classCode=OBS, moodCode=DEFN, isCriterion=true].participation.role.classCode"
}
]
},
{
"id": "Questionnaire.item",
"path": "Questionnaire.item",
"short": "Questions and sections within the Questionnaire",
"definition": "A particular question, question grouping or display text that is part of the questionnaire.",
"comment": "The content of the questionnaire is constructed from an ordered, hierarchical collection of items.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"que-3"
],
"constraint": [
{
"key": "que-9",
"severity": "error",
"human": "Read-only can't be specified for \"display\" items",
"expression": "type!='display' or readOnly.empty()",
"xpath": "not(f:type/@value='display' and f:readOnly)"
},
{
"key": "que-8",
"severity": "error",
"human": "Default values can't be specified for groups or display items",
"expression": "(type!='group' and type!='display') or initial.empty()",
"xpath": "not(f:type/@value=('group', 'display') and f:*[starts-with(local-name(.), 'initial')])"
},
{
"key": "que-6",
"severity": "error",
"human": "Required and repeat aren't permitted for display items",
"expression": "type!='display' or (required.empty() and repeats.empty())",
"xpath": "not(f:type/@value='display' and (f:required or f:repeats))"
},
{
"key": "que-5",
"severity": "error",
"human": "Only 'choice' items can have options",
"expression": "(type ='choice' or type = 'open-choice') or (options.empty() and option.empty())",
"xpath": "f:type/@value=('choice','open-choice') or not(f:option or f:options)"
},
{
"key": "que-4",
"severity": "error",
"human": "A question cannot have both option and options",
"expression": "option.empty() or options.empty()",
"xpath": "not(f:options and f:option)"
},
{
"key": "que-3",
"severity": "error",
"human": "Display items cannot have a \"code\" asserted",
"expression": "type!='display' or code.empty()",
"xpath": "not(f:type/@value='display' and f:code)"
},
{
"key": "que-10",
"severity": "error",
"human": "Maximum length can only be declared for simple question types",
"expression": "(type in ('boolean' | 'decimal' | 'integer' | 'string' | 'text' | 'url')) or maxLength.empty()",
"xpath": "f:type/@value=('boolean', 'decimal', 'integer', 'open-choice', 'string', 'text', 'url') or not(f:maxLength)"
},
{
"key": "que-1",
"severity": "error",
"human": "Group items must have nested items, display items cannot have nested items",
"expression": "(type='group' implies item.empty().not()) and (type.trace('type')='display' implies item.trace('item').empty())",
"xpath": "not((f:type/@value='group' and not(f:item)) or (f:type/@value='display' and f:item))"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=OBS, moodCode=DEF]"
}
]
},
{
"id": "Questionnaire.item.linkId",
"path": "Questionnaire.item.linkId",
"short": "Unique id for item in questionnaire",
"definition": "An identifier that is unique within the Questionnaire allowing linkage to the equivalent item in a QuestionnaireResponse resource.",
"comment": "This ''can'' be a meaningful identifier (e.g. a LOINC code) but is not intended to have any meaning. GUIDs or sequential numbers are appropriate here.",
"requirements": "[QuestionnaireResponse](questionnaireresponse.html#) does not require omitted items to be included and may have some items that repeat, so linkage based on position alone is not sufficient.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "Questionnaire.item.definition",
"path": "Questionnaire.item.definition",
"short": "ElementDefinition - details for the item",
"definition": "A reference to an [ElementDefinition](elementdefinition.html) that provides the details for the item. If a definition is provided, then the following element values can be inferred from the definition: \n\n* code (ElementDefinition.code)\n* type (ElementDefinition.type)\n* required (ElementDefinition.min)\n* repeats (ElementDefinition.max)\n* maxLength (ElementDefinition.maxLength)\n* options (ElementDefinition.binding)\n\nAny information provided in these elements on a Questionnaire Item overrides the information from the definition.",
"comment": "the URI refers to an ElementDefinition in either a [StructureDefinition](structuredefinition.html#) or a [DataElement](dataelement.html#), and always starts with the canonical URL for the target resource. When referring to a StructureDefinition, a fragment identifier is used to specify the element definition by its id [Element.id](element-definitions.html#Element.id). E.g. http://hl7.org/fhir/StructureDefinition/Observation#Observation.value[x]. In the absence of a fragment identifier, the first/root element definition in the target is the matching element definition. Note that [LOINC codes](loinc.html#dataelements) implicitly define DataElement resources.",
"requirements": "A common pattern is to define a set of data elements and then build multiple questionnaires for different circumstances to gather the data. This element provides traceability to the common definition and allows the content for the question to come from the underlying definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=INST].target[classCode=OBS, moodCode=DEF]"
}
]
},
{
"id": "Questionnaire.item.code",
"path": "Questionnaire.item.code",
"short": "Corresponding concept for this item in a terminology",
"definition": "A terminology code that corresponds to this group or question (e.g. a code from LOINC, which defines many questions and answers).",
"comment": "The value may come from the ElementDefinition referred to by .definition.",
"requirements": "Allows linking of groups of questions to formal terminologies.",
"min": 0,
"max": "*",
"type": [
{
"code": "Coding"
}
],
"condition": [
"que-3"
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireConcept"
}
],
"strength": "example",
"description": "Codes for questionnaires, groups and individual questions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-questions"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "Questionnaire.item.prefix",
"path": "Questionnaire.item.prefix",
"short": "E.g. \"1(a)\", \"2.5.3\"",
"definition": "A short label for a particular group, question or set of display text within the questionnaire used for reference by the individual completing the questionnaire.",
"comment": "These are generally unique within a questionnaire, though this is not guaranteed. Some questionnaires may have multiple questions with the same label with logic to control which gets exposed.\n\nTypically these won't be used for \"display\" items, though such use is not prohibited.\n\nSystems SHOULD NOT generate their own prefixes if prefixes are defined for any items within a Questionnaire.",
"requirements": "Separating the label from the question text allows improved rendering. Also, instructions will often refer to specific prefixes, so there's a need for the questionnaire design to have control over what labels are used.",
"alias": [
"label"
],
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "Not supported"
}
]
},
{
"id": "Questionnaire.item.text",
"path": "Questionnaire.item.text",
"short": "Primary text for the item",
"definition": "The name of a section, the text of a question or text content for a display item.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "Questionnaire.item.type",
"path": "Questionnaire.item.type",
"short": "group | display | boolean | decimal | integer | date | dateTime +",
"definition": "The type of questionnaire item this is - whether text for display, a grouping of other items or a particular type of data to be captured (string, integer, coded choice, etc.).",
"comment": "Additional constraints on the type of answer can be conveyed by extensions. The value may come from the ElementDefinition referred to by .definition.",
"requirements": "Defines the format in which the user is to be prompted for the answer.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireItemType"
}
],
"strength": "required",
"description": "Distinguishes groups from questions and display text and indicates data type for questions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/item-type"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.enableWhen",
"path": "Questionnaire.item.enableWhen",
"short": "Only allow data when",
"definition": "A constraint indicating that this item should only be enabled (displayed/allow answers to be captured) when the specified condition is true.",
"comment": "If multiple repetitions of this extension are present, the item should be enabled when the condition for *any* of the repetitions is true. I.e. treat \"enableWhen\"s as being joined by an \"or\" clause.\n\nThis element is a modifier because if enableWhen is present for an item, \"required\" is ignored unless one of the enableWhen conditions is met.",
"requirements": "Allows questionnaires to adapt based on answers to other questions. E.g. If physical gender is specified as a male, no need to capture pregnancy history. Also allows conditional display of instructions or groups of questions.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "que-7",
"severity": "error",
"human": "enableWhen must contain either a 'answer' or a 'hasAnswer' element",
"expression": "hasAnswer.exists() xor answer.exists()",
"xpath": "count(f:*[starts-with(local-name(.), 'answer')]|self::f:hasAnswer) = 1"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.enableWhen.question",
"path": "Questionnaire.item.enableWhen.question",
"short": "Question that determines whether item is enabled",
"definition": "The linkId for the question whose answer (or lack of answer) governs whether this item is enabled.",
"comment": "If multiple question occurrences are present for the same question (same linkId), then this refers to the nearest question occurrence reachable by tracing first the \"ancestor\" axis and then the \"preceding\" axis and then the \"following\" axis.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.enableWhen.hasAnswer",
"path": "Questionnaire.item.enableWhen.hasAnswer",
"short": "Enable when answered or not",
"definition": "An indication that this item should be enabled only if the specified question is answered (hasAnswer=true) or not answered (hasAnswer=false).",
"comment": "If answered=false and answer values are also provided, then they are treated as \"or\". I.e. \"Enable if the question is unanswered or the answer is one of the specified values\". If answered=true and answers are present, one of the specified answers must be met. (So there's little reason to specify answered=true if answers are present.).",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"condition": [
"que-7"
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.enableWhen.answer[x]",
"path": "Questionnaire.item.enableWhen.answer[x]",
"short": "Value question must have",
"definition": "An answer that the referenced question must match in order for the item to be enabled.",
"comment": "Multiple answers are treated as \"or\". E.g. Enable if question 1 = A, C or E. \n\nComponents not specified in the answer do not need to match. For example, if enableWhen specifies code + system for a Coding, it is ok if the answer has a \"display\" element. I.e. treat the answer as a 'pattern'.\n\nThe dataType of this element must be the same as the data type of the question being referenced.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "decimal"
},
{
"code": "integer"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "time"
},
{
"code": "string"
},
{
"code": "uri"
},
{
"code": "Attachment"
},
{
"code": "Coding"
},
{
"code": "Quantity"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"condition": [
"que-7"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireQuestionOption2"
}
],
"strength": "example",
"description": "Allowed values to answer questions.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-answers"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.required",
"path": "Questionnaire.item.required",
"short": "Whether the item must be included in data results",
"definition": "An indication, if true, that the item must be present in a \"completed\" QuestionnaireResponse. If false, the item may be skipped when answering the questionnaire.",
"comment": "Questionnaire.item.required only has meaning for elements that are conditionally enabled with enableWhen if the condition evaluates to true. If an item that contains other items is marked as required, that does not automatically make the contained elements required (though required groups must contain at least one child element). The value may come from the ElementDefinition referred to by .definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false,
"condition": [
"que-6"
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.repeats",
"path": "Questionnaire.item.repeats",
"short": "Whether the item may repeat",
"definition": "An indication, if true, that the item may occur multiple times in the response, collecting multiple answers answers for questions or multiple sets of answers for groups.",
"comment": "If a question is marked as repeats=true, then multiple answers can be provided for the question in the corresponding QuestionnaireResponse. When rendering the questionnaire, it is up to the rendering software whether to render the question text for each answer repetition or to simply list each of the answers beneath the question. (Which is most appropriate visually may depend on the type of answer as well as whether there are nested items.). The value may come from the ElementDefinition referred to by .definition.",
"requirements": "Items may be used to create set of (related) questions that can be repeated to give multiple answers to such a set.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false,
"condition": [
"que-6"
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.readOnly",
"path": "Questionnaire.item.readOnly",
"short": "Don't allow human editing",
"definition": "An indication, when true, that the value cannot be changed by a human respondent to the Questionnaire.",
"comment": "The value of readOnly elements can be established by asserting extensions for defaultValues, linkages that support pre-population and/or extensions that support calculation based on other answers.",
"requirements": "Allows certain information to be phrased (and rendered) as a question and an answer, while keeping users from changing it. May also be useful for preventing changes to pre-populated portions of a questionnaire, for calculated values, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"condition": [
"que-9"
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.maxLength",
"path": "Questionnaire.item.maxLength",
"short": "No more than this many characters",
"definition": "The maximum number of characters that are permitted in the answer to be considered a \"valid\" QuestionnaireResponse.",
"comment": "For base64binary, reflects the number of characters representing the encoded data, not the number of bytes of the binary data. The value may come from the ElementDefinition referred to by .definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"condition": [
"que-10"
],
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.options",
"path": "Questionnaire.item.options",
"short": "Valueset containing permitted answers",
"definition": "A reference to a value set containing a list of codes representing permitted answers for a \"choice\" or \"open-choice\" question.",
"comment": "LOINC defines many useful value sets for questionnaire responses. See [LOINC Answer Lists](loinc.html#alist). The value may come from the ElementDefinition referred to by .definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ValueSet"
}
],
"condition": [
"que-4",
"que-5"
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.option",
"path": "Questionnaire.item.option",
"short": "Permitted answer",
"definition": "One of the permitted answers for a \"choice\" or \"open-choice\" question.",
"comment": "This element can be used when the value set machinery of options is deemed too cumbersome or when there's a need to capture options that are not codes.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"que-4",
"que-5"
],
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.option.value[x]",
"path": "Questionnaire.item.option.value[x]",
"short": "Answer value",
"definition": "A potential answer that's allowed as the answer to this question.",
"comment": "The data type of the value must agree with the item.type.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
},
{
"code": "date"
},
{
"code": "time"
},
{
"code": "string"
},
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireQuestionOption"
}
],
"strength": "example",
"description": "Allowed values to answer questions.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-answers"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.initial[x]",
"path": "Questionnaire.item.initial[x]",
"short": "Default value when item is first rendered",
"definition": "The value that should be defaulted when initially rendering the questionnaire for user input.",
"comment": "The user is allowed to change the value and override the default (unless marked as read-only). If the user doesn't change the value, then this initial value will be persisted when the QuestionnaireResponse is initially created. Note that default values can influence results.\n\nThe data type of initial[x] must agree with the item.type.",
"requirements": "In some workflows, having defaults saves time.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "decimal"
},
{
"code": "integer"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "time"
},
{
"code": "string"
},
{
"code": "uri"
},
{
"code": "Attachment"
},
{
"code": "Coding"
},
{
"code": "Quantity"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"condition": [
"que-8"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireQuestionOption2"
}
],
"strength": "example",
"description": "Allowed values to answer questions.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-answers"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A - MIF rather than RIM level"
}
]
},
{
"id": "Questionnaire.item.item",
"path": "Questionnaire.item.item",
"short": "Nested questionnaire items",
"definition": "Text, questions and other groups to be nested beneath a question or group.",
"comment": "There is no specified limit to the depth of nesting. However, Questionnaire authors are encouraged to consider the impact on the user and user interface of overly deep nesting.",
"requirements": "Reports can consist of complex nested groups.",
"min": 0,
"max": "*",
"contentReference": "#Questionnaire.item",
"condition": [
"que-1"
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/QuestionnaireResponse",
"resource": {
"resourceType": "StructureDefinition",
"id": "QuestionnaireResponse",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints QuestionnaireResponse DomainResource A structured set of questions and their answers
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..1 Identifier Unique id for this set of answers basedOn Σ 0..* Reference(ReferralRequest | CarePlan | ProcedureRequest) Request fulfilled by this QuestionnaireResponse
parent Σ 0..* Reference(Observation | Procedure) Part of this action
questionnaire Σ 0..1 Reference(Questionnaire) Form being answered status ?!Σ 1..1 code in-progress | completed | amended | entered-in-error | stopped
QuestionnaireResponseStatus (Required) subject Σ 0..1 Reference(Any) The subject of the questions context Σ 0..1 Reference(Encounter | EpisodeOfCare) Encounter or Episode during which questionnaire was completed authored Σ 0..1 dateTime Date the answers were gathered author Σ 0..1 Reference(Device | Practitioner | Patient | RelatedPerson) Person who received and recorded the answers source Σ 0..1 Reference(Patient | Practitioner | RelatedPerson) The person who answered the questions item I 0..* BackboneElement Groups and questions
+ Nested item can't be beneath both item and answer
linkId 1..1 string Pointer to specific item from Questionnaire definition 0..1 uri ElementDefinition - details for the item text 0..1 string Name for group or question text subject 0..1 Reference(Any) The subject this group's answers are about answer 0..* BackboneElement The response(s) to the question
value[x] 0..1 Single-valued answer to the question
Questionnaire Answer Codes (Example) valueBoolean boolean valueDecimal decimal valueInteger integer valueDate date valueDateTime dateTime valueTime time valueString string valueUri uri valueAttachment Attachment valueCoding Coding valueQuantity Quantity valueReference Reference(Any) item 0..* see item Nested groups and questions
item 0..* see item Nested questionnaire response items
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/QuestionnaireResponse",
"name": "QuestionnaireResponse",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for QuestionnaireResponse Resource",
"purpose": "To support structured, hierarchical reporting of data gathered using digital forms and other questionnaires.",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "QuestionnaireResponse",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "QuestionnaireResponse",
"path": "QuestionnaireResponse",
"short": "A structured set of questions and their answers",
"definition": "A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to.",
"comment": "The QuestionnaireResponse contains enough information about the questions asked and their organization that it can be interpreted somewhat independently from the Questionnaire it is based on. I.e. You don't need access to the Questionnaire in order to extract basic information from a QuestionnaireResponse.",
"alias": [
"Form",
"QuestionnaireAnswers"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "Observation[moodCode=EVN]"
},
{
"identity": "w5",
"map": "infrastructure.information"
}
]
},
{
"id": "QuestionnaireResponse.id",
"path": "QuestionnaireResponse.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "QuestionnaireResponse.meta",
"path": "QuestionnaireResponse.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "QuestionnaireResponse.implicitRules",
"path": "QuestionnaireResponse.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "QuestionnaireResponse.language",
"path": "QuestionnaireResponse.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "QuestionnaireResponse.text",
"path": "QuestionnaireResponse.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "QuestionnaireResponse.contained",
"path": "QuestionnaireResponse.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "QuestionnaireResponse.extension",
"path": "QuestionnaireResponse.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "QuestionnaireResponse.modifierExtension",
"path": "QuestionnaireResponse.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "QuestionnaireResponse.identifier",
"path": "QuestionnaireResponse.identifier",
"short": "Unique id for this set of answers",
"definition": "A business identifier assigned to a particular completed (or partially completed) questionnaire.",
"requirements": "Used for tracking, registration and other business purposes.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "QuestionnaireResponse.basedOn",
"path": "QuestionnaireResponse.basedOn",
"short": "Request fulfilled by this QuestionnaireResponse",
"definition": "The order, proposal or plan that is fulfilled in whole or in part by this QuestionnaireResponse. For example, a ProcedureRequest seeking an intake assessment or a decision support recommendation to assess for post-partum depression.",
"requirements": "Supports traceability of responsibility for the action and allows linkage of an action to the recommendations acted upon.",
"alias": [
"order"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target"
}
]
},
{
"id": "QuestionnaireResponse.parent",
"path": "QuestionnaireResponse.parent",
"short": "Part of this action",
"definition": "A procedure or observation that this questionnaire was performed as part of the execution of. For example, the surgery a checklist was executed as part of.",
"comment": "Composition of questionnaire responses will be handled by the parent questionnaire having answers that reference the child questionnaire. For relationships to referrals, and other types of requests, use basedOn.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Procedure"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[moodCode=EVN]"
}
]
},
{
"id": "QuestionnaireResponse.questionnaire",
"path": "QuestionnaireResponse.questionnaire",
"short": "Form being answered",
"definition": "The Questionnaire that defines and organizes the questions for which answers are being provided.",
"comment": "If a QuestionnaireResponse references a Questionnaire, then the QuestionnaireResponse structure must be consistent with the Questionnaire (i.e. questions must be organized into the same groups, nested questions must still be nested, etc.).",
"requirements": "Needed to allow editing of the questionnaire response in a manner that enforces the constraints of the original form.",
"alias": [
"Form"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Questionnaire"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "./outboundRelationship[typeCode=INST]/target[classCode=OBS, moodCode=DEFN]"
}
]
},
{
"id": "QuestionnaireResponse.status",
"path": "QuestionnaireResponse.status",
"short": "in-progress | completed | amended | entered-in-error | stopped",
"definition": "The position of the questionnaire response within its overall lifecycle.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"requirements": "The information on Questionnaire resources may possibly be gathered during multiple sessions and altered after considered being finished.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireResponseStatus"
}
],
"strength": "required",
"description": "Lifecycle status of the questionnaire response.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-answers-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".statusCode (also whether there's a revisionControlAct - and possibly mood to distinguish \"in-progress\" from \"published)"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "QuestionnaireResponse.subject",
"path": "QuestionnaireResponse.subject",
"short": "The subject of the questions",
"definition": "The subject of the questionnaire response. This could be a patient, organization, practitioner, device, etc. This is who/what the answers apply to, but is not necessarily the source of information.",
"comment": "If the Questionnaire declared a subjectType, the resource pointed to by this element must be an instance of one of the listed types.",
"requirements": "Allows linking the answers to the individual the answers describe. May also affect access control.",
"alias": [
"Patient",
"Focus"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "QuestionnaireResponse.context",
"path": "QuestionnaireResponse.context",
"short": "Encounter or Episode during which questionnaire was completed",
"definition": "The encounter or episode of care with primary association to the questionnaire response.",
"comment": "A questionnaire that was initiated during an encounter but not fully completed during the encounter would still generally be associated with the encounter.",
"requirements": "Provides context for the information that was captured. May also affect access control.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=COMP].source[classCode<=PCPR, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "QuestionnaireResponse.authored",
"path": "QuestionnaireResponse.authored",
"short": "Date the answers were gathered",
"definition": "The date and/or time that this set of answers were last changed.",
"comment": "May be different from the lastUpdateTime of the resource itself, because that reflects when the data was known to the server, not when the data was captured.\n\nThis element is optional to allow for systems that may not know the value, however it SHOULD be populated if possible.",
"requirements": "Clinicians need to be able to check the date that the information in the questionnaire was collected, to derive the context of the answers.",
"alias": [
"Date Created",
"Date published",
"Date Issued",
"Date updated"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "QuestionnaireResponse.author",
"path": "QuestionnaireResponse.author",
"short": "Person who received and recorded the answers",
"definition": "Person who received the answers to the questions in the QuestionnaireResponse and recorded them in the system.",
"comment": "Mapping a subject's answers to multiple choice options and determining what to put in the textual answer is a matter of interpretation. Authoring by device would indicate that some portion of the questionnaire had been auto-populated.",
"requirements": "Need to know who interpreted the subject's answers to the questions in the questionnaire, and selected the appropriate options for answers.",
"alias": [
"Laboratory",
"Service",
"Practitioner",
"Department",
"Company",
"Performer"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "QuestionnaireResponse.source",
"path": "QuestionnaireResponse.source",
"short": "The person who answered the questions",
"definition": "The person who answered the questions about the subject.",
"comment": "If not specified, no inference can be made about who provided the data.",
"requirements": "When answering questions about a subject that is minor, incapable of answering or an animal, another human source may answer the questions.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=INF].role"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "QuestionnaireResponse.item",
"path": "QuestionnaireResponse.item",
"short": "Groups and questions",
"definition": "A group or question item from the original questionnaire for which answers are provided.",
"comment": "Groups cannot have answers and therefore must nest directly within item. When dealing with questions, nesting must occur within each answer because some questions may have multiple answers (and the nesting occurs for each answer).",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "qrs-1",
"severity": "error",
"human": "Nested item can't be beneath both item and answer",
"expression": "(answer.exists() and item.exists()).not()",
"xpath": "not(exists(f:answer) and exists(f:item))"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "QuestionnaireResponse.item.id",
"path": "QuestionnaireResponse.item.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "QuestionnaireResponse.item.extension",
"path": "QuestionnaireResponse.item.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "QuestionnaireResponse.item.modifierExtension",
"path": "QuestionnaireResponse.item.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "QuestionnaireResponse.item.linkId",
"path": "QuestionnaireResponse.item.linkId",
"short": "Pointer to specific item from Questionnaire",
"definition": "The item from the Questionnaire that corresponds to this item in the QuestionnaireResponse resource.",
"requirements": "Items can repeat in the answers, so a direct 1..1 correspondence by position may not exist - requiring correspondence by identifier.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target[classCode=OBS, moodCode=DEFN].id"
}
]
},
{
"id": "QuestionnaireResponse.item.definition",
"path": "QuestionnaireResponse.item.definition",
"short": "ElementDefinition - details for the item",
"definition": "A reference to an [ElementDefinition](elementdefinition.html) that provides the details for the item.",
"comment": "The ElementDefinition must be in a [StructureDefinition](structuredefinition.html) or a [DataElement](dataelement.html), and must have a fragment identifier that identifies the specific data element by its id (Element.id). E.g. http://hl7.org/fhir/StructureDefinition/Observation#Observation.value[x].\n\nThere is no need for this element if the item pointed to by the linkId has a definition listed.",
"requirements": "A common pattern is to define a set of data elements, and then build multiple different questionnaires for different circumstances to gather the data. This element provides traceability to the common definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target[classCode=OBS, moodCode=DEFN].code"
}
]
},
{
"id": "QuestionnaireResponse.item.text",
"path": "QuestionnaireResponse.item.text",
"short": "Name for group or question text",
"definition": "Text that is displayed above the contents of the group or as the text of the question being answered.",
"requirements": "Allows the questionnaire response to be read without access to the questionnaire.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "QuestionnaireResponse.item.subject",
"path": "QuestionnaireResponse.item.subject",
"short": "The subject this group's answers are about",
"definition": "More specific subject this section's answers are about, details the subject given in QuestionnaireResponse.",
"requirements": "Sometimes a group of answers is about a specific participant, artifact or piece of information in the patient's care or record, e.g. a specific Problem, RelatedPerson, Allergy etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role or .outboundRelationship[typeCode=SUBJ].target"
}
]
},
{
"id": "QuestionnaireResponse.item.answer",
"path": "QuestionnaireResponse.item.answer",
"short": "The response(s) to the question",
"definition": "The respondent's answer(s) to the question.",
"comment": "The value is nested because we cannot have a repeating structure that has variable type.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".value[type=LIST_ANY]"
}
]
},
{
"id": "QuestionnaireResponse.item.answer.id",
"path": "QuestionnaireResponse.item.answer.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "QuestionnaireResponse.item.answer.extension",
"path": "QuestionnaireResponse.item.answer.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "QuestionnaireResponse.item.answer.modifierExtension",
"path": "QuestionnaireResponse.item.answer.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "QuestionnaireResponse.item.answer.value[x]",
"path": "QuestionnaireResponse.item.answer.value[x]",
"short": "Single-valued answer to the question",
"definition": "The answer (or one of the answers) provided by the respondent to the question.",
"comment": "More complex structures (Attachment, Resource and Quantity) will typically be limited to electronic forms that can expose an appropriate user interface to capture the components and enforce the constraints of a complex data type. Additional complex types can be introduced through extensions.",
"requirements": "Ability to retain a single-valued answer to a question.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "decimal"
},
{
"code": "integer"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "time"
},
{
"code": "string"
},
{
"code": "uri"
},
{
"code": "Attachment"
},
{
"code": "Coding"
},
{
"code": "Quantity"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireAnswer"
}
],
"strength": "example",
"description": "Code indicating the response provided for a question.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-answers"
}
},
"mapping": [
{
"identity": "rim",
"map": ".item"
}
]
},
{
"id": "QuestionnaireResponse.item.answer.item",
"path": "QuestionnaireResponse.item.answer.item",
"short": "Nested groups and questions",
"definition": "Nested groups and/or questions found within this particular answer.",
"requirements": "It is useful to have \"sub-questions\", questions which normally appear when certain answers are given and which collect additional details.",
"min": 0,
"max": "*",
"contentReference": "#QuestionnaireResponse.item",
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "QuestionnaireResponse.item.item",
"path": "QuestionnaireResponse.item.item",
"short": "Nested questionnaire response items",
"definition": "Questions or sub-groups nested beneath a question or group.",
"requirements": "Reports can consist of complex nested groups.",
"min": 0,
"max": "*",
"contentReference": "#QuestionnaireResponse.item",
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=OBS, moodCode=EVN]"
}
]
}
]
},
"differential": {
"element": [
{
"id": "QuestionnaireResponse",
"path": "QuestionnaireResponse",
"short": "A structured set of questions and their answers",
"definition": "A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to.",
"comment": "The QuestionnaireResponse contains enough information about the questions asked and their organization that it can be interpreted somewhat independently from the Questionnaire it is based on. I.e. You don't need access to the Questionnaire in order to extract basic information from a QuestionnaireResponse.",
"alias": [
"Form",
"QuestionnaireAnswers"
],
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "Observation[moodCode=EVN]"
},
{
"identity": "w5",
"map": "infrastructure.information"
}
]
},
{
"id": "QuestionnaireResponse.identifier",
"path": "QuestionnaireResponse.identifier",
"short": "Unique id for this set of answers",
"definition": "A business identifier assigned to a particular completed (or partially completed) questionnaire.",
"requirements": "Used for tracking, registration and other business purposes.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "QuestionnaireResponse.basedOn",
"path": "QuestionnaireResponse.basedOn",
"short": "Request fulfilled by this QuestionnaireResponse",
"definition": "The order, proposal or plan that is fulfilled in whole or in part by this QuestionnaireResponse. For example, a ProcedureRequest seeking an intake assessment or a decision support recommendation to assess for post-partum depression.",
"requirements": "Supports traceability of responsibility for the action and allows linkage of an action to the recommendations acted upon.",
"alias": [
"order"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target"
}
]
},
{
"id": "QuestionnaireResponse.parent",
"path": "QuestionnaireResponse.parent",
"short": "Part of this action",
"definition": "A procedure or observation that this questionnaire was performed as part of the execution of. For example, the surgery a checklist was executed as part of.",
"comment": "Composition of questionnaire responses will be handled by the parent questionnaire having answers that reference the child questionnaire. For relationships to referrals, and other types of requests, use basedOn.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Procedure"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[moodCode=EVN]"
}
]
},
{
"id": "QuestionnaireResponse.questionnaire",
"path": "QuestionnaireResponse.questionnaire",
"short": "Form being answered",
"definition": "The Questionnaire that defines and organizes the questions for which answers are being provided.",
"comment": "If a QuestionnaireResponse references a Questionnaire, then the QuestionnaireResponse structure must be consistent with the Questionnaire (i.e. questions must be organized into the same groups, nested questions must still be nested, etc.).",
"requirements": "Needed to allow editing of the questionnaire response in a manner that enforces the constraints of the original form.",
"alias": [
"Form"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Questionnaire"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "./outboundRelationship[typeCode=INST]/target[classCode=OBS, moodCode=DEFN]"
}
]
},
{
"id": "QuestionnaireResponse.status",
"path": "QuestionnaireResponse.status",
"short": "in-progress | completed | amended | entered-in-error | stopped",
"definition": "The position of the questionnaire response within its overall lifecycle.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"requirements": "The information on Questionnaire resources may possibly be gathered during multiple sessions and altered after considered being finished.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireResponseStatus"
}
],
"strength": "required",
"description": "Lifecycle status of the questionnaire response.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-answers-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".statusCode (also whether there's a revisionControlAct - and possibly mood to distinguish \"in-progress\" from \"published)"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "QuestionnaireResponse.subject",
"path": "QuestionnaireResponse.subject",
"short": "The subject of the questions",
"definition": "The subject of the questionnaire response. This could be a patient, organization, practitioner, device, etc. This is who/what the answers apply to, but is not necessarily the source of information.",
"comment": "If the Questionnaire declared a subjectType, the resource pointed to by this element must be an instance of one of the listed types.",
"requirements": "Allows linking the answers to the individual the answers describe. May also affect access control.",
"alias": [
"Patient",
"Focus"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "QuestionnaireResponse.context",
"path": "QuestionnaireResponse.context",
"short": "Encounter or Episode during which questionnaire was completed",
"definition": "The encounter or episode of care with primary association to the questionnaire response.",
"comment": "A questionnaire that was initiated during an encounter but not fully completed during the encounter would still generally be associated with the encounter.",
"requirements": "Provides context for the information that was captured. May also affect access control.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=COMP].source[classCode<=PCPR, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "QuestionnaireResponse.authored",
"path": "QuestionnaireResponse.authored",
"short": "Date the answers were gathered",
"definition": "The date and/or time that this set of answers were last changed.",
"comment": "May be different from the lastUpdateTime of the resource itself, because that reflects when the data was known to the server, not when the data was captured.\n\nThis element is optional to allow for systems that may not know the value, however it SHOULD be populated if possible.",
"requirements": "Clinicians need to be able to check the date that the information in the questionnaire was collected, to derive the context of the answers.",
"alias": [
"Date Created",
"Date published",
"Date Issued",
"Date updated"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "QuestionnaireResponse.author",
"path": "QuestionnaireResponse.author",
"short": "Person who received and recorded the answers",
"definition": "Person who received the answers to the questions in the QuestionnaireResponse and recorded them in the system.",
"comment": "Mapping a subject's answers to multiple choice options and determining what to put in the textual answer is a matter of interpretation. Authoring by device would indicate that some portion of the questionnaire had been auto-populated.",
"requirements": "Need to know who interpreted the subject's answers to the questions in the questionnaire, and selected the appropriate options for answers.",
"alias": [
"Laboratory",
"Service",
"Practitioner",
"Department",
"Company",
"Performer"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "QuestionnaireResponse.source",
"path": "QuestionnaireResponse.source",
"short": "The person who answered the questions",
"definition": "The person who answered the questions about the subject.",
"comment": "If not specified, no inference can be made about who provided the data.",
"requirements": "When answering questions about a subject that is minor, incapable of answering or an animal, another human source may answer the questions.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=INF].role"
},
{
"identity": "w5",
"map": "who.source"
}
]
},
{
"id": "QuestionnaireResponse.item",
"path": "QuestionnaireResponse.item",
"short": "Groups and questions",
"definition": "A group or question item from the original questionnaire for which answers are provided.",
"comment": "Groups cannot have answers and therefore must nest directly within item. When dealing with questions, nesting must occur within each answer because some questions may have multiple answers (and the nesting occurs for each answer).",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "qrs-1",
"severity": "error",
"human": "Nested item can't be beneath both item and answer",
"expression": "(answer.exists() and item.exists()).not()",
"xpath": "not(exists(f:answer) and exists(f:item))"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "QuestionnaireResponse.item.linkId",
"path": "QuestionnaireResponse.item.linkId",
"short": "Pointer to specific item from Questionnaire",
"definition": "The item from the Questionnaire that corresponds to this item in the QuestionnaireResponse resource.",
"requirements": "Items can repeat in the answers, so a direct 1..1 correspondence by position may not exist - requiring correspondence by identifier.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target[classCode=OBS, moodCode=DEFN].id"
}
]
},
{
"id": "QuestionnaireResponse.item.definition",
"path": "QuestionnaireResponse.item.definition",
"short": "ElementDefinition - details for the item",
"definition": "A reference to an [ElementDefinition](elementdefinition.html) that provides the details for the item.",
"comment": "The ElementDefinition must be in a [StructureDefinition](structuredefinition.html) or a [DataElement](dataelement.html), and must have a fragment identifier that identifies the specific data element by its id (Element.id). E.g. http://hl7.org/fhir/StructureDefinition/Observation#Observation.value[x].\n\nThere is no need for this element if the item pointed to by the linkId has a definition listed.",
"requirements": "A common pattern is to define a set of data elements, and then build multiple different questionnaires for different circumstances to gather the data. This element provides traceability to the common definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target[classCode=OBS, moodCode=DEFN].code"
}
]
},
{
"id": "QuestionnaireResponse.item.text",
"path": "QuestionnaireResponse.item.text",
"short": "Name for group or question text",
"definition": "Text that is displayed above the contents of the group or as the text of the question being answered.",
"requirements": "Allows the questionnaire response to be read without access to the questionnaire.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "QuestionnaireResponse.item.subject",
"path": "QuestionnaireResponse.item.subject",
"short": "The subject this group's answers are about",
"definition": "More specific subject this section's answers are about, details the subject given in QuestionnaireResponse.",
"requirements": "Sometimes a group of answers is about a specific participant, artifact or piece of information in the patient's care or record, e.g. a specific Problem, RelatedPerson, Allergy etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role or .outboundRelationship[typeCode=SUBJ].target"
}
]
},
{
"id": "QuestionnaireResponse.item.answer",
"path": "QuestionnaireResponse.item.answer",
"short": "The response(s) to the question",
"definition": "The respondent's answer(s) to the question.",
"comment": "The value is nested because we cannot have a repeating structure that has variable type.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".value[type=LIST_ANY]"
}
]
},
{
"id": "QuestionnaireResponse.item.answer.value[x]",
"path": "QuestionnaireResponse.item.answer.value[x]",
"short": "Single-valued answer to the question",
"definition": "The answer (or one of the answers) provided by the respondent to the question.",
"comment": "More complex structures (Attachment, Resource and Quantity) will typically be limited to electronic forms that can expose an appropriate user interface to capture the components and enforce the constraints of a complex data type. Additional complex types can be introduced through extensions.",
"requirements": "Ability to retain a single-valued answer to a question.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
},
{
"code": "decimal"
},
{
"code": "integer"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "time"
},
{
"code": "string"
},
{
"code": "uri"
},
{
"code": "Attachment"
},
{
"code": "Coding"
},
{
"code": "Quantity"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuestionnaireAnswer"
}
],
"strength": "example",
"description": "Code indicating the response provided for a question.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/questionnaire-answers"
}
},
"mapping": [
{
"identity": "rim",
"map": ".item"
}
]
},
{
"id": "QuestionnaireResponse.item.answer.item",
"path": "QuestionnaireResponse.item.answer.item",
"short": "Nested groups and questions",
"definition": "Nested groups and/or questions found within this particular answer.",
"requirements": "It is useful to have \"sub-questions\", questions which normally appear when certain answers are given and which collect additional details.",
"min": 0,
"max": "*",
"contentReference": "#QuestionnaireResponse.item",
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "QuestionnaireResponse.item.item",
"path": "QuestionnaireResponse.item.item",
"short": "Nested questionnaire response items",
"definition": "Questions or sub-groups nested beneath a question or group.",
"requirements": "Reports can consist of complex nested groups.",
"min": 0,
"max": "*",
"contentReference": "#QuestionnaireResponse.item",
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=COMP].target[classCode=OBS, moodCode=EVN]"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/ReferralRequest",
"resource": {
"resourceType": "StructureDefinition",
"id": "ReferralRequest",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints ReferralRequest DomainResource A request for referral or transfer of care
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier Business identifier
definition Σ 0..* Reference(ActivityDefinition | PlanDefinition) Instantiates protocol or definition
basedOn Σ 0..* Reference(ReferralRequest | CarePlan | ProcedureRequest) Request fulfilled by this request
replaces Σ 0..* Reference(ReferralRequest) Request(s) replaced by this request
groupIdentifier Σ 0..1 Identifier Composite request this is part of status ?!Σ 1..1 code draft | active | suspended | cancelled | completed | entered-in-error | unknown
RequestStatus (Required) intent ?!Σ 1..1 code proposal | plan | order
RequestIntent (Required) type Σ 0..1 CodeableConcept Referral/Transition of care request type
SNOMED CT Patient Referral (Example) priority Σ 0..1 code Urgency of referral / transfer of care request
RequestPriority (Required) serviceRequested Σ 0..* CodeableConcept Actions requested as part of the referral
Practice Setting Code Value Set (Example)
subject Σ 1..1 Reference(Patient | Group) Patient referred to care or transfer context Σ 0..1 Reference(Encounter | EpisodeOfCare) Originating encounter occurrence[x] Σ 0..1 When the service(s) requested in the referral should occur occurrenceDateTime dateTime occurrencePeriod Period authoredOn Σ 0..1 dateTime Date of creation/activation requester ΣI 0..1 BackboneElement Who/what is requesting service
+ onBehalfOf can only be specified if agent is practitioner or device agent Σ 1..1 Reference(Practitioner | Organization | Patient | RelatedPerson | Device) Individual making the request onBehalfOf ΣI 0..1 Reference(Organization) Organization agent is acting for specialty 0..1 CodeableConcept The clinical specialty (discipline) that the referral is requested for
PractitionerSpecialty (Example) recipient Σ 0..* Reference(Practitioner | Organization | HealthcareService) Receiver of referral / transfer of care request
reasonCode Σ 0..* CodeableConcept Reason for referral / transfer of care request
SNOMED CT Clinical Findings (Example)
reasonReference Σ 0..* Reference(Condition | Observation) Why is service needed?
description 0..1 string A textual description of the referral supportingInfo 0..* Reference(Any) Additonal information to support referral or transfer of care request
note 0..* Annotation Comments made about referral request
relevantHistory 0..* Reference(Provenance) Key events in history of request
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 1
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "pc"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/ReferralRequest",
"name": "ReferralRequest",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Patient Care)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/patientcare/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for ReferralRequest Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "ReferralRequest",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "ReferralRequest",
"path": "ReferralRequest",
"short": "A request for referral or transfer of care",
"definition": "Used to record and send details about a request for referral service or transfer of a patient to the care of another provider or provider organization.",
"alias": [
"ReferralRequest TransferOfCare Request"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "w5",
"map": "clinical.careprovision"
}
]
},
{
"id": "ReferralRequest.id",
"path": "ReferralRequest.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "ReferralRequest.meta",
"path": "ReferralRequest.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "ReferralRequest.implicitRules",
"path": "ReferralRequest.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "ReferralRequest.language",
"path": "ReferralRequest.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "ReferralRequest.text",
"path": "ReferralRequest.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "ReferralRequest.contained",
"path": "ReferralRequest.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ReferralRequest.extension",
"path": "ReferralRequest.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ReferralRequest.modifierExtension",
"path": "ReferralRequest.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ReferralRequest.identifier",
"path": "ReferralRequest.identifier",
"short": "Business identifier",
"definition": "Business identifier that uniquely identifies the referral/care transfer request instance.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "RF1-6 / RF1-11"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ReferralRequest.definition",
"path": "ReferralRequest.definition",
"short": "Instantiates protocol or definition",
"definition": "A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target"
}
]
},
{
"id": "ReferralRequest.basedOn",
"path": "ReferralRequest.basedOn",
"short": "Request fulfilled by this request",
"definition": "Indicates any plans, proposals or orders that this request is intended to satisfy - in whole or in part.",
"alias": [
"fulfills"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
}
],
"isModifier": false,
"isSummary": true
},
{
"id": "ReferralRequest.replaces",
"path": "ReferralRequest.replaces",
"short": "Request(s) replaced by this request",
"definition": "Completed or terminated request(s) whose function is taken by this new request.",
"comment": "The replacement could be because the initial request was immediately rejected (due to an issue) or because the previous request was completed, but the need for the action described by the request remains ongoing.",
"requirements": "Allows tracing the continuation of a therapy or administrative process instantiated through multiple requests.",
"alias": [
"supersedes",
"prior",
"renewed order"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RPLC].target"
}
]
},
{
"id": "ReferralRequest.groupIdentifier",
"path": "ReferralRequest.groupIdentifier",
"short": "Composite request this is part of",
"definition": "The business identifier of the logical \"grouping\" request/order that this referral is a part of.",
"requirements": "Allows multiple orders to be collected as part of a single requisition.",
"alias": [
"grouperId",
"requisition"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isModifier": false,
"isSummary": true
},
{
"id": "ReferralRequest.status",
"path": "ReferralRequest.status",
"short": "draft | active | suspended | cancelled | completed | entered-in-error | unknown",
"definition": "The status of the authorization/intention reflected by the referral request record.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"requirements": "Workflow status is handled by the Task resource.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralRequestStatus"
}
],
"strength": "required",
"description": "The status of the referral.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-status"
}
},
"mapping": [
{
"identity": "v2",
"map": "RF1-1"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ReferralRequest.intent",
"path": "ReferralRequest.intent",
"short": "proposal | plan | order",
"definition": "Distinguishes the \"level\" of authorization/demand implicit in this request.",
"requirements": "The same resource structure is used when capturing proposals/recommendations, plans and actual requests.",
"alias": [
"category"
],
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralCategory"
}
],
"strength": "required",
"description": "Codes identifying the stage lifecycle stage of a request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-intent"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ReferralRequest.type",
"path": "ReferralRequest.type",
"short": "Referral/Transition of care request type",
"definition": "An indication of the type of referral (or where applicable the type of transfer of care) request.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isModifier": false,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralType"
}
],
"strength": "example",
"description": "Codes for types of referral; e.g. consult, transfer, temporary transfer.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/referral-type"
}
},
"mapping": [
{
"identity": "v2",
"map": "RF1-10"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ReferralRequest.priority",
"path": "ReferralRequest.priority",
"short": "Urgency of referral / transfer of care request",
"definition": "An indication of the urgency of referral (or where applicable the type of transfer of care) request.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": false,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralPriority"
}
],
"strength": "required",
"description": "Codes indicating the relative priority of the referral.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-priority"
}
},
"mapping": [
{
"identity": "v2",
"map": "RF1-2"
},
{
"identity": "w5",
"map": "grade"
}
]
},
{
"id": "ReferralRequest.serviceRequested",
"path": "ReferralRequest.serviceRequested",
"short": "Actions requested as part of the referral",
"definition": "The service(s) that is/are requested to be provided to the patient. For example: cardiac pacemaker insertion.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isModifier": false,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RequestedService"
}
],
"strength": "example",
"description": "Codes indicating the types of services that might be requested as part of a referral.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/c80-practice-codes"
}
},
"mapping": [
{
"identity": "v2",
"map": "PR1-3 / OBR-4"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "ReferralRequest.subject",
"path": "ReferralRequest.subject",
"short": "Patient referred to care or transfer",
"definition": "The patient who is the subject of a referral or transfer of care request.",
"comment": "Referral of family, group or community is to be catered for by profiles.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "ReferralRequest.context",
"path": "ReferralRequest.context",
"short": "Originating encounter",
"definition": "The encounter at which the request for referral or transfer of care is initiated.",
"alias": [
"encounter"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PV1-19"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "ReferralRequest.occurrence[x]",
"path": "ReferralRequest.occurrence[x]",
"short": "When the service(s) requested in the referral should occur",
"definition": "The period of time within which the services identified in the referral/transfer of care is specified or required to occur.",
"comment": "When the occurrenceDateTime is used, then it is indicating that the requested service must happen before the specified date.",
"requirements": "Use cases: (1) to indicate that the requested service is not to happen before a specified date, and saving the start date in Period.start; (2) to indicate that the requested service must happen before a specified date, and saving the end date in Period.end; (3) to indicate that the requested service must happen during the specified dates (\"start\" and \"end\" values).",
"alias": [
"timing"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "OBR-7/OBR-8"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "ReferralRequest.authoredOn",
"path": "ReferralRequest.authoredOn",
"short": "Date of creation/activation",
"definition": "Date/DateTime of creation for draft requests and date of activation for active requests.",
"alias": [
"createdOn"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "RF1-7 / RF1-9?"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ReferralRequest.requester",
"path": "ReferralRequest.requester",
"short": "Who/what is requesting service",
"definition": "The individual who initiated the request and has responsibility for its activation.",
"alias": [
"author"
],
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "rfr-1",
"severity": "error",
"human": "onBehalfOf can only be specified if agent is practitioner or device",
"expression": "(agent.resolve() is Device) or (agent.resolve() is Practitioner) or onBehalfOf.exists().not()",
"xpath": "contains(f:agent/f:reference/@value, '/Practitioner/') or contains(f:agent/f:reference/@value, '/Device/') or not(exists(f:onBehalfOf))"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
}
]
},
{
"id": "ReferralRequest.requester.id",
"path": "ReferralRequest.requester.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ReferralRequest.requester.extension",
"path": "ReferralRequest.requester.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ReferralRequest.requester.modifierExtension",
"path": "ReferralRequest.requester.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ReferralRequest.requester.agent",
"path": "ReferralRequest.requester.agent",
"short": "Individual making the request",
"definition": "The device, practitioner, etc. who initiated the request.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "ReferralRequest.requester.onBehalfOf",
"path": "ReferralRequest.requester.onBehalfOf",
"short": "Organization agent is acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when authoring the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"condition": [
"rfr-1"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "ReferralRequest.specialty",
"path": "ReferralRequest.specialty",
"short": "The clinical specialty (discipline) that the referral is requested for",
"definition": "Indication of the clinical domain or discipline to which the referral or transfer of care request is sent. For example: Cardiology Gastroenterology Diabetology.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isModifier": false,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralSpecialty"
}
],
"strength": "example",
"description": "Codes indicating the types of capability the referred to service provider must have.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/practitioner-specialty"
}
},
"mapping": [
{
"identity": "v2",
"map": "RF1-3"
}
]
},
{
"id": "ReferralRequest.recipient",
"path": "ReferralRequest.recipient",
"short": "Receiver of referral / transfer of care request",
"definition": "The healthcare provider(s) or provider organization(s) who/which is to receive the referral/transfer of care request.",
"comment": "There will be a primary receiver. But the request can be received by any number of \"copied to\" providers or organizations.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/HealthcareService"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "Practitioner: PRD-2/PRD-7 where PRD-3 = RT; Organization: PRD-10 where PRD-3 = RT"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "ReferralRequest.reasonCode",
"path": "ReferralRequest.reasonCode",
"short": "Reason for referral / transfer of care request",
"definition": "Description of clinical condition indicating why referral/transfer of care is requested. For example: Pathological Anomalies, Disabled (physical or mental), Behavioral Management.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isModifier": false,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralReason"
}
],
"strength": "example",
"description": "Codes indicating why the referral is being requested.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/clinical-findings"
}
},
"mapping": [
{
"identity": "v2",
"map": "RF1-10"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ReferralRequest.reasonReference",
"path": "ReferralRequest.reasonReference",
"short": "Why is service needed?",
"definition": "Indicates another resource whose existence justifies this request.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON].target"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ReferralRequest.description",
"path": "ReferralRequest.description",
"short": "A textual description of the referral",
"definition": "The reason element gives a short description of why the referral is being made, the description expands on this to support a more complete clinical summary.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isModifier": false
},
{
"id": "ReferralRequest.supportingInfo",
"path": "ReferralRequest.supportingInfo",
"short": "Additonal information to support referral or transfer of care request",
"definition": "Any additional (administrative, financial or clinical) information required to support request for referral or transfer of care. For example: Presenting problems/chief complaints Medical History Family History Alerts Allergy/Intolerance and Adverse Reactions Medications Observations/Assessments (may include cognitive and fundtional assessments) Diagnostic Reports Care Plan.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isModifier": false
},
{
"id": "ReferralRequest.note",
"path": "ReferralRequest.note",
"short": "Comments made about referral request",
"definition": "Comments made about the referral request by any of the participants.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
]
},
{
"id": "ReferralRequest.relevantHistory",
"path": "ReferralRequest.relevantHistory",
"short": "Key events in history of request",
"definition": "Links to Provenance records for past versions of this resource or fulfilling request or event resources that identify key state transitions or updates that are likely to be relevant to a user looking at the current version of the resource.",
"comment": "This element does not point to the Provenance associated with the *current* version of the resource - as it would be created after this version existed. The Provenance for the current version can be retrieved with a _revinclude.",
"alias": [
"eventHistory"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
}
]
},
"differential": {
"element": [
{
"id": "ReferralRequest",
"path": "ReferralRequest",
"short": "A request for referral or transfer of care",
"definition": "Used to record and send details about a request for referral service or transfer of a patient to the care of another provider or provider organization.",
"alias": [
"ReferralRequest TransferOfCare Request"
],
"min": 0,
"max": "*",
"mapping": [
{
"identity": "w5",
"map": "clinical.careprovision"
}
]
},
{
"id": "ReferralRequest.identifier",
"path": "ReferralRequest.identifier",
"short": "Business identifier",
"definition": "Business identifier that uniquely identifies the referral/care transfer request instance.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "RF1-6 / RF1-11"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ReferralRequest.definition",
"path": "ReferralRequest.definition",
"short": "Instantiates protocol or definition",
"definition": "A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target"
}
]
},
{
"id": "ReferralRequest.basedOn",
"path": "ReferralRequest.basedOn",
"short": "Request fulfilled by this request",
"definition": "Indicates any plans, proposals or orders that this request is intended to satisfy - in whole or in part.",
"alias": [
"fulfills"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CarePlan"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
}
],
"isModifier": false,
"isSummary": true
},
{
"id": "ReferralRequest.replaces",
"path": "ReferralRequest.replaces",
"short": "Request(s) replaced by this request",
"definition": "Completed or terminated request(s) whose function is taken by this new request.",
"comment": "The replacement could be because the initial request was immediately rejected (due to an issue) or because the previous request was completed, but the need for the action described by the request remains ongoing.",
"requirements": "Allows tracing the continuation of a therapy or administrative process instantiated through multiple requests.",
"alias": [
"supersedes",
"prior",
"renewed order"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ReferralRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RPLC].target"
}
]
},
{
"id": "ReferralRequest.groupIdentifier",
"path": "ReferralRequest.groupIdentifier",
"short": "Composite request this is part of",
"definition": "The business identifier of the logical \"grouping\" request/order that this referral is a part of.",
"requirements": "Allows multiple orders to be collected as part of a single requisition.",
"alias": [
"grouperId",
"requisition"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isModifier": false,
"isSummary": true
},
{
"id": "ReferralRequest.status",
"path": "ReferralRequest.status",
"short": "draft | active | suspended | cancelled | completed | entered-in-error | unknown",
"definition": "The status of the authorization/intention reflected by the referral request record.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"requirements": "Workflow status is handled by the Task resource.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralRequestStatus"
}
],
"strength": "required",
"description": "The status of the referral.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-status"
}
},
"mapping": [
{
"identity": "v2",
"map": "RF1-1"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ReferralRequest.intent",
"path": "ReferralRequest.intent",
"short": "proposal | plan | order",
"definition": "Distinguishes the \"level\" of authorization/demand implicit in this request.",
"requirements": "The same resource structure is used when capturing proposals/recommendations, plans and actual requests.",
"alias": [
"category"
],
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralCategory"
}
],
"strength": "required",
"description": "Codes identifying the stage lifecycle stage of a request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-intent"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ReferralRequest.type",
"path": "ReferralRequest.type",
"short": "Referral/Transition of care request type",
"definition": "An indication of the type of referral (or where applicable the type of transfer of care) request.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isModifier": false,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralType"
}
],
"strength": "example",
"description": "Codes for types of referral; e.g. consult, transfer, temporary transfer.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/referral-type"
}
},
"mapping": [
{
"identity": "v2",
"map": "RF1-10"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ReferralRequest.priority",
"path": "ReferralRequest.priority",
"short": "Urgency of referral / transfer of care request",
"definition": "An indication of the urgency of referral (or where applicable the type of transfer of care) request.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": false,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralPriority"
}
],
"strength": "required",
"description": "Codes indicating the relative priority of the referral.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-priority"
}
},
"mapping": [
{
"identity": "v2",
"map": "RF1-2"
},
{
"identity": "w5",
"map": "grade"
}
]
},
{
"id": "ReferralRequest.serviceRequested",
"path": "ReferralRequest.serviceRequested",
"short": "Actions requested as part of the referral",
"definition": "The service(s) that is/are requested to be provided to the patient. For example: cardiac pacemaker insertion.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isModifier": false,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RequestedService"
}
],
"strength": "example",
"description": "Codes indicating the types of services that might be requested as part of a referral.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/c80-practice-codes"
}
},
"mapping": [
{
"identity": "v2",
"map": "PR1-3 / OBR-4"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "ReferralRequest.subject",
"path": "ReferralRequest.subject",
"short": "Patient referred to care or transfer",
"definition": "The patient who is the subject of a referral or transfer of care request.",
"comment": "Referral of family, group or community is to be catered for by profiles.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "ReferralRequest.context",
"path": "ReferralRequest.context",
"short": "Originating encounter",
"definition": "The encounter at which the request for referral or transfer of care is initiated.",
"alias": [
"encounter"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PV1-19"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "ReferralRequest.occurrence[x]",
"path": "ReferralRequest.occurrence[x]",
"short": "When the service(s) requested in the referral should occur",
"definition": "The period of time within which the services identified in the referral/transfer of care is specified or required to occur.",
"comment": "When the occurrenceDateTime is used, then it is indicating that the requested service must happen before the specified date.",
"requirements": "Use cases: (1) to indicate that the requested service is not to happen before a specified date, and saving the start date in Period.start; (2) to indicate that the requested service must happen before a specified date, and saving the end date in Period.end; (3) to indicate that the requested service must happen during the specified dates (\"start\" and \"end\" values).",
"alias": [
"timing"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "OBR-7/OBR-8"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "ReferralRequest.authoredOn",
"path": "ReferralRequest.authoredOn",
"short": "Date of creation/activation",
"definition": "Date/DateTime of creation for draft requests and date of activation for active requests.",
"alias": [
"createdOn"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "RF1-7 / RF1-9?"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ReferralRequest.requester",
"path": "ReferralRequest.requester",
"short": "Who/what is requesting service",
"definition": "The individual who initiated the request and has responsibility for its activation.",
"alias": [
"author"
],
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "rfr-1",
"severity": "error",
"human": "onBehalfOf can only be specified if agent is practitioner or device",
"expression": "(agent.resolve() is Device) or (agent.resolve() is Practitioner) or onBehalfOf.exists().not()",
"xpath": "contains(f:agent/f:reference/@value, '/Practitioner/') or contains(f:agent/f:reference/@value, '/Device/') or not(exists(f:onBehalfOf))"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
}
]
},
{
"id": "ReferralRequest.requester.agent",
"path": "ReferralRequest.requester.agent",
"short": "Individual making the request",
"definition": "The device, practitioner, etc. who initiated the request.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "ReferralRequest.requester.onBehalfOf",
"path": "ReferralRequest.requester.onBehalfOf",
"short": "Organization agent is acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when authoring the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"condition": [
"rfr-1"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "ReferralRequest.specialty",
"path": "ReferralRequest.specialty",
"short": "The clinical specialty (discipline) that the referral is requested for",
"definition": "Indication of the clinical domain or discipline to which the referral or transfer of care request is sent. For example: Cardiology Gastroenterology Diabetology.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isModifier": false,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralSpecialty"
}
],
"strength": "example",
"description": "Codes indicating the types of capability the referred to service provider must have.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/practitioner-specialty"
}
},
"mapping": [
{
"identity": "v2",
"map": "RF1-3"
}
]
},
{
"id": "ReferralRequest.recipient",
"path": "ReferralRequest.recipient",
"short": "Receiver of referral / transfer of care request",
"definition": "The healthcare provider(s) or provider organization(s) who/which is to receive the referral/transfer of care request.",
"comment": "There will be a primary receiver. But the request can be received by any number of \"copied to\" providers or organizations.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/HealthcareService"
}
],
"isModifier": false,
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "Practitioner: PRD-2/PRD-7 where PRD-3 = RT; Organization: PRD-10 where PRD-3 = RT"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "ReferralRequest.reasonCode",
"path": "ReferralRequest.reasonCode",
"short": "Reason for referral / transfer of care request",
"definition": "Description of clinical condition indicating why referral/transfer of care is requested. For example: Pathological Anomalies, Disabled (physical or mental), Behavioral Management.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isModifier": false,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ReferralReason"
}
],
"strength": "example",
"description": "Codes indicating why the referral is being requested.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/clinical-findings"
}
},
"mapping": [
{
"identity": "v2",
"map": "RF1-10"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ReferralRequest.reasonReference",
"path": "ReferralRequest.reasonReference",
"short": "Why is service needed?",
"definition": "Indicates another resource whose existence justifies this request.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=RSON].target"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ReferralRequest.description",
"path": "ReferralRequest.description",
"short": "A textual description of the referral",
"definition": "The reason element gives a short description of why the referral is being made, the description expands on this to support a more complete clinical summary.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isModifier": false
},
{
"id": "ReferralRequest.supportingInfo",
"path": "ReferralRequest.supportingInfo",
"short": "Additonal information to support referral or transfer of care request",
"definition": "Any additional (administrative, financial or clinical) information required to support request for referral or transfer of care. For example: Presenting problems/chief complaints Medical History Family History Alerts Allergy/Intolerance and Adverse Reactions Medications Observations/Assessments (may include cognitive and fundtional assessments) Diagnostic Reports Care Plan.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isModifier": false
},
{
"id": "ReferralRequest.note",
"path": "ReferralRequest.note",
"short": "Comments made about referral request",
"definition": "Comments made about the referral request by any of the participants.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
]
},
{
"id": "ReferralRequest.relevantHistory",
"path": "ReferralRequest.relevantHistory",
"short": "Key events in history of request",
"definition": "Links to Provenance records for past versions of this resource or fulfilling request or event resources that identify key state transitions or updates that are likely to be relevant to a user looking at the current version of the resource.",
"comment": "This element does not point to the Provenance associated with the *current* version of the resource - as it would be created after this version existed. The Provenance for the current version can be retrieved with a _revinclude.",
"alias": [
"eventHistory"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/RelatedPerson",
"resource": {
"resourceType": "StructureDefinition",
"id": "RelatedPerson",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints RelatedPerson DomainResource An person that is related to a patient, but who is not a direct target of care
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier A human identifier for this person
active ?!Σ 0..1 boolean Whether this related person's record is in active use patient Σ 1..1 Reference(Patient) The patient this person is related to relationship Σ 0..1 CodeableConcept The nature of the relationship
PatientRelationshipType (Preferred) name Σ 0..* HumanName A name associated with the person
telecom Σ 0..* ContactPoint A contact detail for the person
gender Σ 0..1 code male | female | other | unknown
AdministrativeGender (Required) birthDate Σ 0..1 date The date on which the related person was born address Σ 0..* Address Address where the related person can be contacted or visited
photo 0..* Attachment Image of the person
period 0..1 Period Period of time that this relationship is considered valid
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "pa"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/RelatedPerson",
"name": "RelatedPerson",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Patient Administration)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/pafm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for RelatedPerson Resource",
"purpose": "Need to track persons related to the patient or the healthcare process.",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "RelatedPerson",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "RelatedPerson",
"path": "RelatedPerson",
"short": "An person that is related to a patient, but who is not a direct target of care",
"definition": "Information about a person that is involved in the care for a patient, but who is not the target of healthcare, nor has a formal responsibility in the care process.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "role"
},
{
"identity": "w5",
"map": "administrative.individual"
}
]
},
{
"id": "RelatedPerson.id",
"path": "RelatedPerson.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "RelatedPerson.meta",
"path": "RelatedPerson.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "RelatedPerson.implicitRules",
"path": "RelatedPerson.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "RelatedPerson.language",
"path": "RelatedPerson.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "RelatedPerson.text",
"path": "RelatedPerson.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "RelatedPerson.contained",
"path": "RelatedPerson.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RelatedPerson.extension",
"path": "RelatedPerson.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RelatedPerson.modifierExtension",
"path": "RelatedPerson.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RelatedPerson.identifier",
"path": "RelatedPerson.identifier",
"short": "A human identifier for this person",
"definition": "Identifier for a person within a particular scope.",
"requirements": "People are known by a variety of ids. Some institutions maintain several, and most collect identifiers for exchange with other organizations concerning the patient. Examples are national person identifier and local identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "NK1-33"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "RelatedPerson.active",
"path": "RelatedPerson.active",
"short": "Whether this related person's record is in active use",
"definition": "Whether this related person record is in active use.",
"comment": "This element is labeled as a modifier because it may be used to mark that the resource was created in error.",
"requirements": "Need to be able to mark a related person record as not to be used, such as if it was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "RelatedPerson.patient",
"path": "RelatedPerson.patient",
"short": "The patient this person is related to",
"definition": "The patient this person is related to.",
"requirements": "We need to know which patient this RelatedPerson is related to.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "rim",
"map": "scoper[classCode=PSN|ANM and determinerCode='INSTANCE']/playedRole[classCode='PAT']/id"
}
]
},
{
"id": "RelatedPerson.relationship",
"path": "RelatedPerson.relationship",
"short": "The nature of the relationship",
"definition": "The nature of the relationship between a patient and the related person.",
"requirements": "We need to know the relationship with the patient since it influences the interpretation of the information attributed to this person.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PatientRelationshipType"
}
],
"strength": "preferred",
"description": "The nature of the relationship between a patient and the related person",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/relatedperson-relationshiptype"
}
},
"mapping": [
{
"identity": "v2",
"map": "NK1-3"
},
{
"identity": "rim",
"map": "code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "RelatedPerson.name",
"path": "RelatedPerson.name",
"short": "A name associated with the person",
"definition": "A name associated with the person.",
"requirements": "Related persons need to be identified by name, but it is uncommon to need details about multiple other names for that person.",
"min": 0,
"max": "*",
"type": [
{
"code": "HumanName"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "NK1-2"
},
{
"identity": "rim",
"map": "name"
}
]
},
{
"id": "RelatedPerson.telecom",
"path": "RelatedPerson.telecom",
"short": "A contact detail for the person",
"definition": "A contact detail for the person, e.g. a telephone number or an email address.",
"comment": "Person may have multiple ways to be contacted with different uses or applicable periods. May need to have options for contacting the person urgently, and also to help with identification.",
"requirements": "People have (primary) ways to contact them in some way such as phone, email.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "NK1-5 / NK1-6 / NK1-40"
},
{
"identity": "rim",
"map": "telecom"
}
]
},
{
"id": "RelatedPerson.gender",
"path": "RelatedPerson.gender",
"short": "male | female | other | unknown",
"definition": "Administrative Gender - the gender that the person is considered to have for administration and record keeping purposes.",
"requirements": "Needed for identification of the person, in combination with (at least) name and birth date.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdministrativeGender"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The gender of a person used for administrative purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administrative-gender"
}
},
"mapping": [
{
"identity": "v2",
"map": "NK1-15"
},
{
"identity": "rim",
"map": "administrativeGender"
}
]
},
{
"id": "RelatedPerson.birthDate",
"path": "RelatedPerson.birthDate",
"short": "The date on which the related person was born",
"definition": "The date on which the related person was born.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "player.birthTime"
}
]
},
{
"id": "RelatedPerson.address",
"path": "RelatedPerson.address",
"short": "Address where the related person can be contacted or visited",
"definition": "Address where the related person can be contacted or visited.",
"requirements": "Need to keep track where the related person can be contacted per postal mail or visited.",
"min": 0,
"max": "*",
"type": [
{
"code": "Address"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "NK1-4"
},
{
"identity": "rim",
"map": "addr"
}
]
},
{
"id": "RelatedPerson.photo",
"path": "RelatedPerson.photo",
"short": "Image of the person",
"definition": "Image of the person.",
"requirements": "Many EHR systems have the capability to capture an image of persons. Fits with newer social media usage too.",
"min": 0,
"max": "*",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX-5 - needs a profile"
},
{
"identity": "rim",
"map": "player[classCode='PSN' and determinerCode='INSTANCE']/desc"
}
]
},
{
"id": "RelatedPerson.period",
"path": "RelatedPerson.period",
"short": "Period of time that this relationship is considered valid",
"definition": "The period of time that this relationship is considered to be valid. If there are no dates defined, then the interval is unknown.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
}
]
},
"differential": {
"element": [
{
"id": "RelatedPerson",
"path": "RelatedPerson",
"short": "An person that is related to a patient, but who is not a direct target of care",
"definition": "Information about a person that is involved in the care for a patient, but who is not the target of healthcare, nor has a formal responsibility in the care process.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "role"
},
{
"identity": "w5",
"map": "administrative.individual"
}
]
},
{
"id": "RelatedPerson.identifier",
"path": "RelatedPerson.identifier",
"short": "A human identifier for this person",
"definition": "Identifier for a person within a particular scope.",
"requirements": "People are known by a variety of ids. Some institutions maintain several, and most collect identifiers for exchange with other organizations concerning the patient. Examples are national person identifier and local identifier.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "NK1-33"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "RelatedPerson.active",
"path": "RelatedPerson.active",
"short": "Whether this related person's record is in active use",
"definition": "Whether this related person record is in active use.",
"comment": "This element is labeled as a modifier because it may be used to mark that the resource was created in error.",
"requirements": "Need to be able to mark a related person record as not to be used, such as if it was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "RelatedPerson.patient",
"path": "RelatedPerson.patient",
"short": "The patient this person is related to",
"definition": "The patient this person is related to.",
"requirements": "We need to know which patient this RelatedPerson is related to.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PID-3"
},
{
"identity": "rim",
"map": "scoper[classCode=PSN|ANM and determinerCode='INSTANCE']/playedRole[classCode='PAT']/id"
}
]
},
{
"id": "RelatedPerson.relationship",
"path": "RelatedPerson.relationship",
"short": "The nature of the relationship",
"definition": "The nature of the relationship between a patient and the related person.",
"requirements": "We need to know the relationship with the patient since it influences the interpretation of the information attributed to this person.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PatientRelationshipType"
}
],
"strength": "preferred",
"description": "The nature of the relationship between a patient and the related person",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/relatedperson-relationshiptype"
}
},
"mapping": [
{
"identity": "v2",
"map": "NK1-3"
},
{
"identity": "rim",
"map": "code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "RelatedPerson.name",
"path": "RelatedPerson.name",
"short": "A name associated with the person",
"definition": "A name associated with the person.",
"requirements": "Related persons need to be identified by name, but it is uncommon to need details about multiple other names for that person.",
"min": 0,
"max": "*",
"type": [
{
"code": "HumanName"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "NK1-2"
},
{
"identity": "rim",
"map": "name"
}
]
},
{
"id": "RelatedPerson.telecom",
"path": "RelatedPerson.telecom",
"short": "A contact detail for the person",
"definition": "A contact detail for the person, e.g. a telephone number or an email address.",
"comment": "Person may have multiple ways to be contacted with different uses or applicable periods. May need to have options for contacting the person urgently, and also to help with identification.",
"requirements": "People have (primary) ways to contact them in some way such as phone, email.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "NK1-5 / NK1-6 / NK1-40"
},
{
"identity": "rim",
"map": "telecom"
}
]
},
{
"id": "RelatedPerson.gender",
"path": "RelatedPerson.gender",
"short": "male | female | other | unknown",
"definition": "Administrative Gender - the gender that the person is considered to have for administration and record keeping purposes.",
"requirements": "Needed for identification of the person, in combination with (at least) name and birth date.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AdministrativeGender"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The gender of a person used for administrative purposes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/administrative-gender"
}
},
"mapping": [
{
"identity": "v2",
"map": "NK1-15"
},
{
"identity": "rim",
"map": "administrativeGender"
}
]
},
{
"id": "RelatedPerson.birthDate",
"path": "RelatedPerson.birthDate",
"short": "The date on which the related person was born",
"definition": "The date on which the related person was born.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "player.birthTime"
}
]
},
{
"id": "RelatedPerson.address",
"path": "RelatedPerson.address",
"short": "Address where the related person can be contacted or visited",
"definition": "Address where the related person can be contacted or visited.",
"requirements": "Need to keep track where the related person can be contacted per postal mail or visited.",
"min": 0,
"max": "*",
"type": [
{
"code": "Address"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "NK1-4"
},
{
"identity": "rim",
"map": "addr"
}
]
},
{
"id": "RelatedPerson.photo",
"path": "RelatedPerson.photo",
"short": "Image of the person",
"definition": "Image of the person.",
"requirements": "Many EHR systems have the capability to capture an image of persons. Fits with newer social media usage too.",
"min": 0,
"max": "*",
"type": [
{
"code": "Attachment"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX-5 - needs a profile"
},
{
"identity": "rim",
"map": "player[classCode='PSN' and determinerCode='INSTANCE']/desc"
}
]
},
{
"id": "RelatedPerson.period",
"path": "RelatedPerson.period",
"short": "Period of time that this relationship is considered valid",
"definition": "The period of time that this relationship is considered to be valid. If there are no dates defined, then the interval is unknown.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/RequestGroup",
"resource": {
"resourceType": "StructureDefinition",
"id": "RequestGroup",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints RequestGroup DomainResource A group of related requests
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier Business identifier
definition 0..* Reference(Any) Instantiates protocol or definition
basedOn 0..* Reference(Any) Fulfills plan, proposal, or order
replaces 0..* Reference(Any) Request(s) replaced by this request
groupIdentifier Σ 0..1 Identifier Composite request this is part of status ?!Σ 1..1 code draft | active | suspended | cancelled | completed | entered-in-error | unknown
RequestStatus (Required) intent ?!Σ 1..1 code proposal | plan | order
RequestIntent (Required) priority Σ 0..1 code routine | urgent | asap | stat
RequestPriority (Required) subject 0..1 Reference(Patient | Group) Who the request group is about context 0..1 Reference(Encounter | EpisodeOfCare) Encounter or Episode for the request group authoredOn 0..1 dateTime When the request group was authored author 0..1 Reference(Device | Practitioner) Device or practitioner that authored the request group reason[x] 0..1 Reason for the request group reasonCodeableConcept CodeableConcept reasonReference Reference(Any) note 0..* Annotation Additional notes about the response
action I 0..* BackboneElement Proposed actions, if any
+ Must have resource or action but not both
label 0..1 string User-visible label for the action (e.g. 1. or A.) title 0..1 string User-visible title description Σ 0..1 string Short description of the action textEquivalent Σ 0..1 string Static text equivalent of the action, used if the dynamic aspects cannot be interpreted by the receiving system code 0..* CodeableConcept Code representing the meaning of the action or sub-actions
documentation 0..* RelatedArtifact Supporting documentation for the intended performer of the action
condition 0..* BackboneElement Whether or not the action is applicable
kind 1..1 code applicability | start | stop
ActionConditionKind (Required) description 0..1 string Natural language description of the condition language 0..1 string Language of the expression expression 0..1 string Boolean-valued expression relatedAction 0..* BackboneElement Relationship to another action
actionId 1..1 id What action this is related to relationship 1..1 code before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end
ActionRelationshipType (Required) offset[x] 0..1 Time offset for the relationship offsetDuration Duration offsetRange Range timing[x] 0..1 When the action should take place timingDateTime dateTime timingPeriod Period timingDuration Duration timingRange Range timingTiming Timing participant 0..* Reference(Patient | Person | Practitioner | RelatedPerson) Who should perform the action
type 0..1 Coding create | update | remove | fire-event
ActionType (Extensible) groupingBehavior 0..1 code visual-group | logical-group | sentence-group
ActionGroupingBehavior (Required) selectionBehavior 0..1 code any | all | all-or-none | exactly-one | at-most-one | one-or-more
ActionSelectionBehavior (Required) requiredBehavior 0..1 code must | could | must-unless-documented
ActionRequiredBehavior (Required) precheckBehavior 0..1 code yes | no
ActionPrecheckBehavior (Required) cardinalityBehavior 0..1 code single | multiple
ActionCardinalityBehavior (Required) resource I 0..1 Reference(Any) The target of the action action I 0..* see action Sub action
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 0
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "cds"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/RequestGroup",
"name": "RequestGroup",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Clinical Decision Support)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/dss/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for RequestGroup Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "RequestGroup",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "RequestGroup",
"path": "RequestGroup",
"short": "A group of related requests",
"definition": "A group of related requests that can be used to capture intended activities that have inter-dependencies such as \"give this medication after that one\".",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "RequestGroup.id",
"path": "RequestGroup.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "RequestGroup.meta",
"path": "RequestGroup.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "RequestGroup.implicitRules",
"path": "RequestGroup.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "RequestGroup.language",
"path": "RequestGroup.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "RequestGroup.text",
"path": "RequestGroup.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "RequestGroup.contained",
"path": "RequestGroup.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RequestGroup.extension",
"path": "RequestGroup.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RequestGroup.modifierExtension",
"path": "RequestGroup.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RequestGroup.identifier",
"path": "RequestGroup.identifier",
"short": "Business identifier",
"definition": "Allows a service to provide a unique, business identifier for the request.",
"requirements": "Allows identification of the request as it is known by various participating systems and in a way that remains consistent across servers.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "RequestGroup.definition",
"path": "RequestGroup.definition",
"short": "Instantiates protocol or definition",
"definition": "A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
}
]
},
{
"id": "RequestGroup.basedOn",
"path": "RequestGroup.basedOn",
"short": "Fulfills plan, proposal, or order",
"definition": "A plan, proposal or order that is fulfilled in whole or in part by this request.",
"requirements": "Allows tracing of authorization for the request and tracking whether proposals/recommendations were acted upon.",
"alias": [
"fulfills"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.basedOn"
}
]
},
{
"id": "RequestGroup.replaces",
"path": "RequestGroup.replaces",
"short": "Request(s) replaced by this request",
"definition": "Completed or terminated request(s) whose function is taken by this new request.",
"comment": "The replacement could be because the initial request was immediately rejected (due to an issue) or because the previous request was completed, but the need for the action described by the request remains ongoing.",
"requirements": "Allows tracing the continuation of a therapy or administrative process instantiated through multiple requests.",
"alias": [
"supersedes",
"prior",
"renewed order"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.replaces"
}
]
},
{
"id": "RequestGroup.groupIdentifier",
"path": "RequestGroup.groupIdentifier",
"short": "Composite request this is part of",
"definition": "A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition, prescription or similar form.",
"comment": "Requests are linked either by a \"basedOn\" relationship (i.e. one request is fulfilling another) or by having a common requisition. Requests that are part of the same requisition are generally treated independently from the perspective of changing their state or maintaining them after initial creation.",
"requirements": "Some business processes need to know if multiple items were ordered as part of the same \"prescription\" or \"requisition\" for billing or other purposes.",
"alias": [
"grouperid",
"requisition"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.groupIdentifier"
}
]
},
{
"id": "RequestGroup.status",
"path": "RequestGroup.status",
"short": "draft | active | suspended | cancelled | completed | entered-in-error | unknown",
"definition": "The current state of the request. For request groups, the status reflects the status of all the requests in the group.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RequestStatus"
}
],
"strength": "required",
"description": "Codes identifying the stage lifecycle stage of a request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "RequestGroup.intent",
"path": "RequestGroup.intent",
"short": "proposal | plan | order",
"definition": "Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.",
"comment": "This element is labeled as a modifier because the intent alters when and how the resource is actually applicable.",
"requirements": "Proposals/recommendations, plans and orders all use the same structure and can exist in the same fulfillment chain.",
"alias": [
"category"
],
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RequestIntent"
}
],
"strength": "required",
"description": "Codes indicating the degree of authority/intentionality associated with a request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-intent"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.intent"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "RequestGroup.priority",
"path": "RequestGroup.priority",
"short": "routine | urgent | asap | stat",
"definition": "Indicates how quickly the request should be addressed with respect to other requests.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "If missing, this request should be performed with normal priority",
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RequestPriority"
}
],
"strength": "required",
"description": "Identifies the level of importance to be assigned to actioning the request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-priority"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.priority"
},
{
"identity": "w5",
"map": "grade"
}
]
},
{
"id": "RequestGroup.subject",
"path": "RequestGroup.subject",
"short": "Who the request group is about",
"definition": "The subject for which the request group was created.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.subject"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "RequestGroup.context",
"path": "RequestGroup.context",
"short": "Encounter or Episode for the request group",
"definition": "Describes the context of the request group, if any.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.context"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "RequestGroup.authoredOn",
"path": "RequestGroup.authoredOn",
"short": "When the request group was authored",
"definition": "Indicates when the request group was created.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "RequestGroup.author",
"path": "RequestGroup.author",
"short": "Device or practitioner that authored the request group",
"definition": "Provides a reference to the author of the request group.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.author"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "RequestGroup.reason[x]",
"path": "RequestGroup.reason[x]",
"short": "Reason for the request group",
"definition": "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.reason"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "RequestGroup.note",
"path": "RequestGroup.note",
"short": "Additional notes about the response",
"definition": "Provides a mechanism to communicate additional information about the response.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.note"
}
]
},
{
"id": "RequestGroup.action",
"path": "RequestGroup.action",
"short": "Proposed actions, if any",
"definition": "The actions, if any, produced by the evaluation of the artifact.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "rqg-1",
"severity": "error",
"human": "Must have resource or action but not both",
"expression": "resource.exists() != action.exists()",
"xpath": "exists(f:resource) != exists(f:action)"
}
]
},
{
"id": "RequestGroup.action.id",
"path": "RequestGroup.action.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "RequestGroup.action.extension",
"path": "RequestGroup.action.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "RequestGroup.action.modifierExtension",
"path": "RequestGroup.action.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RequestGroup.action.label",
"path": "RequestGroup.action.label",
"short": "User-visible label for the action (e.g. 1. or A.)",
"definition": "A user-visible label for the action.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "RequestGroup.action.title",
"path": "RequestGroup.action.title",
"short": "User-visible title",
"definition": "The title of the action displayed to a user.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "RequestGroup.action.description",
"path": "RequestGroup.action.description",
"short": "Short description of the action",
"definition": "A short description of the action used to provide a summary to display to the user.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "RequestGroup.action.textEquivalent",
"path": "RequestGroup.action.textEquivalent",
"short": "Static text equivalent of the action, used if the dynamic aspects cannot be interpreted by the receiving system",
"definition": "A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "RequestGroup.action.code",
"path": "RequestGroup.action.code",
"short": "Code representing the meaning of the action or sub-actions",
"definition": "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.code"
}
]
},
{
"id": "RequestGroup.action.documentation",
"path": "RequestGroup.action.documentation",
"short": "Supporting documentation for the intended performer of the action",
"definition": "Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.supportingInfo"
}
]
},
{
"id": "RequestGroup.action.condition",
"path": "RequestGroup.action.condition",
"short": "Whether or not the action is applicable",
"definition": "An expression that describes applicability criteria, or start/stop conditions for the action.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "RequestGroup.action.condition.id",
"path": "RequestGroup.action.condition.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "RequestGroup.action.condition.extension",
"path": "RequestGroup.action.condition.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "RequestGroup.action.condition.modifierExtension",
"path": "RequestGroup.action.condition.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RequestGroup.action.condition.kind",
"path": "RequestGroup.action.condition.kind",
"short": "applicability | start | stop",
"definition": "The kind of condition.",
"comment": "Applicability criteria are used to determine immediate applicability when a plan definition is applied to a given context. Start and stop criteria are carried through application and used to describe when enter/exit criteria for an action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionConditionKind"
}
],
"strength": "required",
"description": "The kind of condition for the action",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-condition-kind"
}
}
},
{
"id": "RequestGroup.action.condition.description",
"path": "RequestGroup.action.condition.description",
"short": "Natural language description of the condition",
"definition": "A brief, natural language description of the condition that effectively communicates the intended semantics.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "RequestGroup.action.condition.language",
"path": "RequestGroup.action.condition.language",
"short": "Language of the expression",
"definition": "The media type of the language for the expression.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "RequestGroup.action.condition.expression",
"path": "RequestGroup.action.condition.expression",
"short": "Boolean-valued expression",
"definition": "An expression that returns true or false, indicating whether or not the condition is satisfied.",
"comment": "The expression may be inlined, or may be a reference to a named expression within a logic library referenced by the library element.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "RequestGroup.action.relatedAction",
"path": "RequestGroup.action.relatedAction",
"short": "Relationship to another action",
"definition": "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "RequestGroup.action.relatedAction.id",
"path": "RequestGroup.action.relatedAction.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "RequestGroup.action.relatedAction.extension",
"path": "RequestGroup.action.relatedAction.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "RequestGroup.action.relatedAction.modifierExtension",
"path": "RequestGroup.action.relatedAction.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RequestGroup.action.relatedAction.actionId",
"path": "RequestGroup.action.relatedAction.actionId",
"short": "What action this is related to",
"definition": "The element id of the action this is related to.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "RequestGroup.action.relatedAction.relationship",
"path": "RequestGroup.action.relatedAction.relationship",
"short": "before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end",
"definition": "The relationship of this action to the related action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionRelationshipType"
}
],
"strength": "required",
"description": "Defines the types of relationships between actions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-relationship-type"
}
}
},
{
"id": "RequestGroup.action.relatedAction.offset[x]",
"path": "RequestGroup.action.relatedAction.offset[x]",
"short": "Time offset for the relationship",
"definition": "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.",
"min": 0,
"max": "1",
"type": [
{
"code": "Duration"
},
{
"code": "Range"
}
]
},
{
"id": "RequestGroup.action.timing[x]",
"path": "RequestGroup.action.timing[x]",
"short": "When the action should take place",
"definition": "An optional value describing when the action should be performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
},
{
"code": "Duration"
},
{
"code": "Range"
},
{
"code": "Timing"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.occurrence"
}
]
},
{
"id": "RequestGroup.action.participant",
"path": "RequestGroup.action.participant",
"short": "Who should perform the action",
"definition": "The participant that should perform or be responsible for this action.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Person"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.performer"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "RequestGroup.action.type",
"path": "RequestGroup.action.type",
"short": "create | update | remove | fire-event",
"definition": "The type of action to perform (create, update, remove).",
"min": 0,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionType"
}
],
"strength": "extensible",
"description": "The type of action to be performed",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-type"
}
}
},
{
"id": "RequestGroup.action.groupingBehavior",
"path": "RequestGroup.action.groupingBehavior",
"short": "visual-group | logical-group | sentence-group",
"definition": "Defines the grouping behavior for the action and its children.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionGroupingBehavior"
}
],
"strength": "required",
"description": "Defines organization behavior of a group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-grouping-behavior"
}
}
},
{
"id": "RequestGroup.action.selectionBehavior",
"path": "RequestGroup.action.selectionBehavior",
"short": "any | all | all-or-none | exactly-one | at-most-one | one-or-more",
"definition": "Defines the selection behavior for the action and its children.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionSelectionBehavior"
}
],
"strength": "required",
"description": "Defines selection behavior of a group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-selection-behavior"
}
}
},
{
"id": "RequestGroup.action.requiredBehavior",
"path": "RequestGroup.action.requiredBehavior",
"short": "must | could | must-unless-documented",
"definition": "Defines the requiredness behavior for the action.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionRequiredBehavior"
}
],
"strength": "required",
"description": "Defines requiredness behavior for selecting an action or an action group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-required-behavior"
}
}
},
{
"id": "RequestGroup.action.precheckBehavior",
"path": "RequestGroup.action.precheckBehavior",
"short": "yes | no",
"definition": "Defines whether the action should usually be preselected.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionPrecheckBehavior"
}
],
"strength": "required",
"description": "Defines selection frequency behavior for an action or group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-precheck-behavior"
}
}
},
{
"id": "RequestGroup.action.cardinalityBehavior",
"path": "RequestGroup.action.cardinalityBehavior",
"short": "single | multiple",
"definition": "Defines whether the action can be selected multiple times.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionCardinalityBehavior"
}
],
"strength": "required",
"description": "Defines behavior for an action or a group for how many times that item may be repeated",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-cardinality-behavior"
}
}
},
{
"id": "RequestGroup.action.resource",
"path": "RequestGroup.action.resource",
"short": "The target of the action",
"definition": "The resource that is the target of the action (e.g. CommunicationRequest).",
"comment": "The target resource SHALL be a [Request](request.html) resource with a Request.intent set to \"option\".",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"condition": [
"rqg-1"
]
},
{
"id": "RequestGroup.action.action",
"path": "RequestGroup.action.action",
"short": "Sub action",
"definition": "Sub actions.",
"min": 0,
"max": "*",
"contentReference": "#RequestGroup.action",
"condition": [
"rqg-1"
]
}
]
},
"differential": {
"element": [
{
"id": "RequestGroup",
"path": "RequestGroup",
"short": "A group of related requests",
"definition": "A group of related requests that can be used to capture intended activities that have inter-dependencies such as \"give this medication after that one\".",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "RequestGroup.identifier",
"path": "RequestGroup.identifier",
"short": "Business identifier",
"definition": "Allows a service to provide a unique, business identifier for the request.",
"requirements": "Allows identification of the request as it is known by various participating systems and in a way that remains consistent across servers.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "RequestGroup.definition",
"path": "RequestGroup.definition",
"short": "Instantiates protocol or definition",
"definition": "A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
}
]
},
{
"id": "RequestGroup.basedOn",
"path": "RequestGroup.basedOn",
"short": "Fulfills plan, proposal, or order",
"definition": "A plan, proposal or order that is fulfilled in whole or in part by this request.",
"requirements": "Allows tracing of authorization for the request and tracking whether proposals/recommendations were acted upon.",
"alias": [
"fulfills"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.basedOn"
}
]
},
{
"id": "RequestGroup.replaces",
"path": "RequestGroup.replaces",
"short": "Request(s) replaced by this request",
"definition": "Completed or terminated request(s) whose function is taken by this new request.",
"comment": "The replacement could be because the initial request was immediately rejected (due to an issue) or because the previous request was completed, but the need for the action described by the request remains ongoing.",
"requirements": "Allows tracing the continuation of a therapy or administrative process instantiated through multiple requests.",
"alias": [
"supersedes",
"prior",
"renewed order"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.replaces"
}
]
},
{
"id": "RequestGroup.groupIdentifier",
"path": "RequestGroup.groupIdentifier",
"short": "Composite request this is part of",
"definition": "A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition, prescription or similar form.",
"comment": "Requests are linked either by a \"basedOn\" relationship (i.e. one request is fulfilling another) or by having a common requisition. Requests that are part of the same requisition are generally treated independently from the perspective of changing their state or maintaining them after initial creation.",
"requirements": "Some business processes need to know if multiple items were ordered as part of the same \"prescription\" or \"requisition\" for billing or other purposes.",
"alias": [
"grouperid",
"requisition"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.groupIdentifier"
}
]
},
{
"id": "RequestGroup.status",
"path": "RequestGroup.status",
"short": "draft | active | suspended | cancelled | completed | entered-in-error | unknown",
"definition": "The current state of the request. For request groups, the status reflects the status of all the requests in the group.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RequestStatus"
}
],
"strength": "required",
"description": "Codes identifying the stage lifecycle stage of a request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "RequestGroup.intent",
"path": "RequestGroup.intent",
"short": "proposal | plan | order",
"definition": "Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.",
"comment": "This element is labeled as a modifier because the intent alters when and how the resource is actually applicable.",
"requirements": "Proposals/recommendations, plans and orders all use the same structure and can exist in the same fulfillment chain.",
"alias": [
"category"
],
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RequestIntent"
}
],
"strength": "required",
"description": "Codes indicating the degree of authority/intentionality associated with a request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-intent"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.intent"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "RequestGroup.priority",
"path": "RequestGroup.priority",
"short": "routine | urgent | asap | stat",
"definition": "Indicates how quickly the request should be addressed with respect to other requests.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "If missing, this request should be performed with normal priority",
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RequestPriority"
}
],
"strength": "required",
"description": "Identifies the level of importance to be assigned to actioning the request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-priority"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.priority"
},
{
"identity": "w5",
"map": "grade"
}
]
},
{
"id": "RequestGroup.subject",
"path": "RequestGroup.subject",
"short": "Who the request group is about",
"definition": "The subject for which the request group was created.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.subject"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "RequestGroup.context",
"path": "RequestGroup.context",
"short": "Encounter or Episode for the request group",
"definition": "Describes the context of the request group, if any.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.context"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "RequestGroup.authoredOn",
"path": "RequestGroup.authoredOn",
"short": "When the request group was authored",
"definition": "Indicates when the request group was created.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "RequestGroup.author",
"path": "RequestGroup.author",
"short": "Device or practitioner that authored the request group",
"definition": "Provides a reference to the author of the request group.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.author"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "RequestGroup.reason[x]",
"path": "RequestGroup.reason[x]",
"short": "Reason for the request group",
"definition": "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.reason"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "RequestGroup.note",
"path": "RequestGroup.note",
"short": "Additional notes about the response",
"definition": "Provides a mechanism to communicate additional information about the response.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.note"
}
]
},
{
"id": "RequestGroup.action",
"path": "RequestGroup.action",
"short": "Proposed actions, if any",
"definition": "The actions, if any, produced by the evaluation of the artifact.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "rqg-1",
"severity": "error",
"human": "Must have resource or action but not both",
"expression": "resource.exists() != action.exists()",
"xpath": "exists(f:resource) != exists(f:action)"
}
]
},
{
"id": "RequestGroup.action.label",
"path": "RequestGroup.action.label",
"short": "User-visible label for the action (e.g. 1. or A.)",
"definition": "A user-visible label for the action.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "RequestGroup.action.title",
"path": "RequestGroup.action.title",
"short": "User-visible title",
"definition": "The title of the action displayed to a user.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "RequestGroup.action.description",
"path": "RequestGroup.action.description",
"short": "Short description of the action",
"definition": "A short description of the action used to provide a summary to display to the user.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "RequestGroup.action.textEquivalent",
"path": "RequestGroup.action.textEquivalent",
"short": "Static text equivalent of the action, used if the dynamic aspects cannot be interpreted by the receiving system",
"definition": "A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "RequestGroup.action.code",
"path": "RequestGroup.action.code",
"short": "Code representing the meaning of the action or sub-actions",
"definition": "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.code"
}
]
},
{
"id": "RequestGroup.action.documentation",
"path": "RequestGroup.action.documentation",
"short": "Supporting documentation for the intended performer of the action",
"definition": "Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.supportingInfo"
}
]
},
{
"id": "RequestGroup.action.condition",
"path": "RequestGroup.action.condition",
"short": "Whether or not the action is applicable",
"definition": "An expression that describes applicability criteria, or start/stop conditions for the action.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "RequestGroup.action.condition.kind",
"path": "RequestGroup.action.condition.kind",
"short": "applicability | start | stop",
"definition": "The kind of condition.",
"comment": "Applicability criteria are used to determine immediate applicability when a plan definition is applied to a given context. Start and stop criteria are carried through application and used to describe when enter/exit criteria for an action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionConditionKind"
}
],
"strength": "required",
"description": "The kind of condition for the action",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-condition-kind"
}
}
},
{
"id": "RequestGroup.action.condition.description",
"path": "RequestGroup.action.condition.description",
"short": "Natural language description of the condition",
"definition": "A brief, natural language description of the condition that effectively communicates the intended semantics.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "RequestGroup.action.condition.language",
"path": "RequestGroup.action.condition.language",
"short": "Language of the expression",
"definition": "The media type of the language for the expression.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "RequestGroup.action.condition.expression",
"path": "RequestGroup.action.condition.expression",
"short": "Boolean-valued expression",
"definition": "An expression that returns true or false, indicating whether or not the condition is satisfied.",
"comment": "The expression may be inlined, or may be a reference to a named expression within a logic library referenced by the library element.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "RequestGroup.action.relatedAction",
"path": "RequestGroup.action.relatedAction",
"short": "Relationship to another action",
"definition": "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "RequestGroup.action.relatedAction.actionId",
"path": "RequestGroup.action.relatedAction.actionId",
"short": "What action this is related to",
"definition": "The element id of the action this is related to.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "RequestGroup.action.relatedAction.relationship",
"path": "RequestGroup.action.relatedAction.relationship",
"short": "before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end",
"definition": "The relationship of this action to the related action.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionRelationshipType"
}
],
"strength": "required",
"description": "Defines the types of relationships between actions",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-relationship-type"
}
}
},
{
"id": "RequestGroup.action.relatedAction.offset[x]",
"path": "RequestGroup.action.relatedAction.offset[x]",
"short": "Time offset for the relationship",
"definition": "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.",
"min": 0,
"max": "1",
"type": [
{
"code": "Duration"
},
{
"code": "Range"
}
]
},
{
"id": "RequestGroup.action.timing[x]",
"path": "RequestGroup.action.timing[x]",
"short": "When the action should take place",
"definition": "An optional value describing when the action should be performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
},
{
"code": "Duration"
},
{
"code": "Range"
},
{
"code": "Timing"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.occurrence"
}
]
},
{
"id": "RequestGroup.action.participant",
"path": "RequestGroup.action.participant",
"short": "Who should perform the action",
"definition": "The participant that should perform or be responsible for this action.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Person"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.performer"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "RequestGroup.action.type",
"path": "RequestGroup.action.type",
"short": "create | update | remove | fire-event",
"definition": "The type of action to perform (create, update, remove).",
"min": 0,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionType"
}
],
"strength": "extensible",
"description": "The type of action to be performed",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-type"
}
}
},
{
"id": "RequestGroup.action.groupingBehavior",
"path": "RequestGroup.action.groupingBehavior",
"short": "visual-group | logical-group | sentence-group",
"definition": "Defines the grouping behavior for the action and its children.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionGroupingBehavior"
}
],
"strength": "required",
"description": "Defines organization behavior of a group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-grouping-behavior"
}
}
},
{
"id": "RequestGroup.action.selectionBehavior",
"path": "RequestGroup.action.selectionBehavior",
"short": "any | all | all-or-none | exactly-one | at-most-one | one-or-more",
"definition": "Defines the selection behavior for the action and its children.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionSelectionBehavior"
}
],
"strength": "required",
"description": "Defines selection behavior of a group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-selection-behavior"
}
}
},
{
"id": "RequestGroup.action.requiredBehavior",
"path": "RequestGroup.action.requiredBehavior",
"short": "must | could | must-unless-documented",
"definition": "Defines the requiredness behavior for the action.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionRequiredBehavior"
}
],
"strength": "required",
"description": "Defines requiredness behavior for selecting an action or an action group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-required-behavior"
}
}
},
{
"id": "RequestGroup.action.precheckBehavior",
"path": "RequestGroup.action.precheckBehavior",
"short": "yes | no",
"definition": "Defines whether the action should usually be preselected.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionPrecheckBehavior"
}
],
"strength": "required",
"description": "Defines selection frequency behavior for an action or group",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-precheck-behavior"
}
}
},
{
"id": "RequestGroup.action.cardinalityBehavior",
"path": "RequestGroup.action.cardinalityBehavior",
"short": "single | multiple",
"definition": "Defines whether the action can be selected multiple times.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ActionCardinalityBehavior"
}
],
"strength": "required",
"description": "Defines behavior for an action or a group for how many times that item may be repeated",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/action-cardinality-behavior"
}
}
},
{
"id": "RequestGroup.action.resource",
"path": "RequestGroup.action.resource",
"short": "The target of the action",
"definition": "The resource that is the target of the action (e.g. CommunicationRequest).",
"comment": "The target resource SHALL be a [Request](request.html) resource with a Request.intent set to \"option\".",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"condition": [
"rqg-1"
]
},
{
"id": "RequestGroup.action.action",
"path": "RequestGroup.action.action",
"short": "Sub action",
"definition": "Sub actions.",
"min": 0,
"max": "*",
"contentReference": "#RequestGroup.action",
"condition": [
"rqg-1"
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/ResearchStudy",
"resource": {
"resourceType": "StructureDefinition",
"id": "ResearchStudy",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints ResearchStudy DomainResource Investigation to increase healthcare-related patient-independent knowledge
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier Business Identifier for study
title Σ 0..1 string Name for this study protocol Σ 0..* Reference(PlanDefinition) Steps followed in executing study
partOf Σ 0..* Reference(ResearchStudy) Part of larger study
status ?!Σ 1..1 code draft | in-progress | suspended | stopped | completed | entered-in-error
ResearchStudyStatus (Required) category Σ 0..* CodeableConcept Classifications for the study
focus Σ 0..* CodeableConcept Drugs, devices, conditions, etc. under study
contact Σ 0..* ContactDetail Contact details for the study
relatedArtifact 0..* RelatedArtifact References and dependencies
keyword Σ 0..* CodeableConcept Used to search for the study
jurisdiction Σ 0..* CodeableConcept Geographic region(s) for study
Jurisdiction ValueSet (Extensible)
description 0..1 markdown What this is study doing enrollment Σ 0..* Reference(Group) Inclusion & exclusion criteria
period Σ 0..1 Period When the study began and ended sponsor Σ 0..1 Reference(Organization) Organization responsible for the study principalInvestigator Σ 0..1 Reference(Practitioner) The individual responsible for the study site Σ 0..* Reference(Location) Location involved in study execution
reasonStopped Σ 0..1 CodeableConcept Reason for terminating study early note 0..* Annotation Comments made about the event
arm 0..* BackboneElement Defined path through the study for a subject
name 1..1 string Label for study arm code 0..1 CodeableConcept Categorization of study arm description 0..1 string Short explanation of study path
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 0
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "rcrim"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/ResearchStudy",
"name": "ResearchStudy",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Regulated Clinical Research Information Management)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/rcrim/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for ResearchStudy Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "clinicaltrials-gov",
"uri": "http://clinicaltrials.gov",
"name": "ClinicalTrials.gov Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "ResearchStudy",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "ResearchStudy",
"path": "ResearchStudy",
"short": "Investigation to increase healthcare-related patient-independent knowledge",
"definition": "A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge. This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques. A ResearchStudy involves the gathering of information about human or animal subjects.",
"comment": "Need to make sure we encompass public health studies.",
"alias": [
"Clinical Trial",
"Study"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "v2",
"map": "OBX"
},
{
"identity": "rim",
"map": "Observation[classCode=CLNTRL, moodCode=EVN]"
},
{
"identity": "w5",
"map": "clinical.diagnostics"
}
]
},
{
"id": "ResearchStudy.id",
"path": "ResearchStudy.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "ResearchStudy.meta",
"path": "ResearchStudy.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "ResearchStudy.implicitRules",
"path": "ResearchStudy.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "ResearchStudy.language",
"path": "ResearchStudy.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "ResearchStudy.text",
"path": "ResearchStudy.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "ResearchStudy.contained",
"path": "ResearchStudy.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ResearchStudy.extension",
"path": "ResearchStudy.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ResearchStudy.modifierExtension",
"path": "ResearchStudy.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ResearchStudy.identifier",
"path": "ResearchStudy.identifier",
"short": "Business Identifier for study",
"definition": "Identifiers assigned to this research study by the sponsor or other systems.",
"requirements": "Allows identification of the research study as it is known by various participating systems and in a way that remains consistent across servers.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Organization's Unique Protocol ID; Secondary IDs"
},
{
"identity": "rim",
"map": ".identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ResearchStudy.title",
"path": "ResearchStudy.title",
"short": "Name for this study",
"definition": "A short, descriptive user-friendly label for the study.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Brief Title"
}
]
},
{
"id": "ResearchStudy.protocol",
"path": "ResearchStudy.protocol",
"short": "Steps followed in executing study",
"definition": "The set of steps expected to be performed as part of the execution of the study.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Interventions; Arm/Intervention Cross-Reference"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target"
}
]
},
{
"id": "ResearchStudy.partOf",
"path": "ResearchStudy.partOf",
"short": "Part of larger study",
"definition": "A larger research study of which this particular study is a component or step.",
"requirements": "Allows breaking a study into components (e.g. by study site) each with their own PI, status, enrollment, etc.",
"alias": [
"container"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ResearchStudy"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[moodCode=EVN]"
}
]
},
{
"id": "ResearchStudy.status",
"path": "ResearchStudy.status",
"short": "draft | in-progress | suspended | stopped | completed | entered-in-error",
"definition": "The current state of the study.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResearchStudyStatus"
}
],
"strength": "required",
"description": "Codes that convey the current status of the research study",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/research-study-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ResearchStudy.category",
"path": "ResearchStudy.category",
"short": "Classifications for the study",
"definition": "Codes categorizing the type of study such as investigational vs. observational, type of blinding, type of randomization, safety vs. efficacy, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResearchStudyCategory"
}
],
"strength": "example",
"description": "Codes that describe the type of research study. E.g. Study phase, Interventional/Observational, blinding type, etc."
},
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Study Type; Primary Purpose; Study Phase; Interventional Model; Masking; Allocation; study Classification; Observational Study Model; Time Perspective; Biospecimen Retention"
}
]
},
{
"id": "ResearchStudy.focus",
"path": "ResearchStudy.focus",
"short": "Drugs, devices, conditions, etc. under study",
"definition": "The condition(s), medication(s), food(s), therapy(ies), device(s) or other concerns or interventions that the study is seeking to gain more information about.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResearchStudyFocus"
}
],
"strength": "example",
"description": "Codes for medications, devices, conditions and other interventions"
},
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Conditions or Focus of Study"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "ResearchStudy.contact",
"path": "ResearchStudy.contact",
"short": "Contact details for the study",
"definition": "Contact details to assist a user in learning more about or engaging with the study.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Central Contact; Central Contact Backup; Overall Study Officials; Facility Contact & Backup (if Study tied to only one location); Investigators"
}
]
},
{
"id": "ResearchStudy.relatedArtifact",
"path": "ResearchStudy.relatedArtifact",
"short": "References and dependencies",
"definition": "Citations, references and other related documents.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Citations, Links, Available Study Data/Documents"
}
]
},
{
"id": "ResearchStudy.keyword",
"path": "ResearchStudy.keyword",
"short": "Used to search for the study",
"definition": "Key terms to aid in searching for or filtering the study.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResearchStudyKeyword"
}
],
"strength": "example",
"description": "Words associated with the study that may be useful in discovery"
},
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Keywords"
}
]
},
{
"id": "ResearchStudy.jurisdiction",
"path": "ResearchStudy.jurisdiction",
"short": "Geographic region(s) for study",
"definition": "Indicates a country, state or other region where the study is taking place.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "ResearchStudy.description",
"path": "ResearchStudy.description",
"short": "What this is study doing",
"definition": "A full description of how the study is being conducted.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Detailed Description"
}
]
},
{
"id": "ResearchStudy.enrollment",
"path": "ResearchStudy.enrollment",
"short": "Inclusion & exclusion criteria",
"definition": "Reference to a Group that defines the criteria for and quantity of subjects participating in the study. E.g. \" 200 female Europeans between the ages of 20 and 45 with early onset diabetes\".",
"comment": "The Group referenced should not generally enumerate specific subjects. Subjects will be linked to the study using the ResearchSubject resource.",
"alias": [
"patient"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Enrollment; Number of Groups/Cohorts (= number of \"enrollment\" instances); Groups (Group/Cohort Label = Group.name; Group/Cohort Description = Group.description); Eligibility (Group criteria)"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "ResearchStudy.period",
"path": "ResearchStudy.period",
"short": "When the study began and ended",
"definition": "Identifies the start date and the expected (or actual, depending on status) end date for the study.",
"requirements": "[The list of types may be constrained as appropriate for the type of event].",
"alias": [
"timing"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Study Start Date (start); Study Completion Date (end)"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "ResearchStudy.sponsor",
"path": "ResearchStudy.sponsor",
"short": "Organization responsible for the study",
"definition": "The organization responsible for the execution of the study.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Sponsor"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "ResearchStudy.principalInvestigator",
"path": "ResearchStudy.principalInvestigator",
"short": "The individual responsible for the study",
"definition": "Indicates the individual who has primary oversite of the execution of the study.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Principal Investigator"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "ResearchStudy.site",
"path": "ResearchStudy.site",
"short": "Location involved in study execution",
"definition": "Clinic, hospital or other healthcare location that is participating in the study.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Facility"
},
{
"identity": "w5",
"map": "where"
}
]
},
{
"id": "ResearchStudy.reasonStopped",
"path": "ResearchStudy.reasonStopped",
"short": "Reason for terminating study early",
"definition": "A description and/or code explaining the premature termination of the study.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Why Study Stopped"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ResearchStudy.note",
"path": "ResearchStudy.note",
"short": "Comments made about the event",
"definition": "Comments made about the event by the performer, subject or other participants.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
]
},
{
"id": "ResearchStudy.arm",
"path": "ResearchStudy.arm",
"short": "Defined path through the study for a subject",
"definition": "Describes an expected sequence of events for one of the participants of a study. E.g. Exposure to drug A, wash-out, exposure to drug B, wash-out, follow-up.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Arms"
}
]
},
{
"id": "ResearchStudy.arm.id",
"path": "ResearchStudy.arm.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ResearchStudy.arm.extension",
"path": "ResearchStudy.arm.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ResearchStudy.arm.modifierExtension",
"path": "ResearchStudy.arm.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ResearchStudy.arm.name",
"path": "ResearchStudy.arm.name",
"short": "Label for study arm",
"definition": "Unique, human-readable label for this arm of the study.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Arm Label"
}
]
},
{
"id": "ResearchStudy.arm.code",
"path": "ResearchStudy.arm.code",
"short": "Categorization of study arm",
"definition": "Categorization of study arm, e.g. experimental, active comparator, placebo comparater.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Arm Type"
}
]
},
{
"id": "ResearchStudy.arm.description",
"path": "ResearchStudy.arm.description",
"short": "Short explanation of study path",
"definition": "A succinct description of the path through the study that would be followed by a subject adhering to this arm.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Arm Description"
}
]
}
]
},
"differential": {
"element": [
{
"id": "ResearchStudy",
"path": "ResearchStudy",
"short": "Investigation to increase healthcare-related patient-independent knowledge",
"definition": "A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge. This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques. A ResearchStudy involves the gathering of information about human or animal subjects.",
"comment": "Need to make sure we encompass public health studies.",
"alias": [
"Clinical Trial",
"Study"
],
"min": 0,
"max": "*",
"mapping": [
{
"identity": "v2",
"map": "OBX"
},
{
"identity": "rim",
"map": "Observation[classCode=CLNTRL, moodCode=EVN]"
},
{
"identity": "w5",
"map": "clinical.diagnostics"
}
]
},
{
"id": "ResearchStudy.identifier",
"path": "ResearchStudy.identifier",
"short": "Business Identifier for study",
"definition": "Identifiers assigned to this research study by the sponsor or other systems.",
"requirements": "Allows identification of the research study as it is known by various participating systems and in a way that remains consistent across servers.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Organization's Unique Protocol ID; Secondary IDs"
},
{
"identity": "rim",
"map": ".identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ResearchStudy.title",
"path": "ResearchStudy.title",
"short": "Name for this study",
"definition": "A short, descriptive user-friendly label for the study.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Brief Title"
}
]
},
{
"id": "ResearchStudy.protocol",
"path": "ResearchStudy.protocol",
"short": "Steps followed in executing study",
"definition": "The set of steps expected to be performed as part of the execution of the study.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PlanDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Interventions; Arm/Intervention Cross-Reference"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target"
}
]
},
{
"id": "ResearchStudy.partOf",
"path": "ResearchStudy.partOf",
"short": "Part of larger study",
"definition": "A larger research study of which this particular study is a component or step.",
"requirements": "Allows breaking a study into components (e.g. by study site) each with their own PI, status, enrollment, etc.",
"alias": [
"container"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ResearchStudy"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[moodCode=EVN]"
}
]
},
{
"id": "ResearchStudy.status",
"path": "ResearchStudy.status",
"short": "draft | in-progress | suspended | stopped | completed | entered-in-error",
"definition": "The current state of the study.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResearchStudyStatus"
}
],
"strength": "required",
"description": "Codes that convey the current status of the research study",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/research-study-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ResearchStudy.category",
"path": "ResearchStudy.category",
"short": "Classifications for the study",
"definition": "Codes categorizing the type of study such as investigational vs. observational, type of blinding, type of randomization, safety vs. efficacy, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResearchStudyCategory"
}
],
"strength": "example",
"description": "Codes that describe the type of research study. E.g. Study phase, Interventional/Observational, blinding type, etc."
},
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Study Type; Primary Purpose; Study Phase; Interventional Model; Masking; Allocation; study Classification; Observational Study Model; Time Perspective; Biospecimen Retention"
}
]
},
{
"id": "ResearchStudy.focus",
"path": "ResearchStudy.focus",
"short": "Drugs, devices, conditions, etc. under study",
"definition": "The condition(s), medication(s), food(s), therapy(ies), device(s) or other concerns or interventions that the study is seeking to gain more information about.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResearchStudyFocus"
}
],
"strength": "example",
"description": "Codes for medications, devices, conditions and other interventions"
},
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Conditions or Focus of Study"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "ResearchStudy.contact",
"path": "ResearchStudy.contact",
"short": "Contact details for the study",
"definition": "Contact details to assist a user in learning more about or engaging with the study.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Central Contact; Central Contact Backup; Overall Study Officials; Facility Contact & Backup (if Study tied to only one location); Investigators"
}
]
},
{
"id": "ResearchStudy.relatedArtifact",
"path": "ResearchStudy.relatedArtifact",
"short": "References and dependencies",
"definition": "Citations, references and other related documents.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Citations, Links, Available Study Data/Documents"
}
]
},
{
"id": "ResearchStudy.keyword",
"path": "ResearchStudy.keyword",
"short": "Used to search for the study",
"definition": "Key terms to aid in searching for or filtering the study.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResearchStudyKeyword"
}
],
"strength": "example",
"description": "Words associated with the study that may be useful in discovery"
},
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Keywords"
}
]
},
{
"id": "ResearchStudy.jurisdiction",
"path": "ResearchStudy.jurisdiction",
"short": "Geographic region(s) for study",
"definition": "Indicates a country, state or other region where the study is taking place.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "ResearchStudy.description",
"path": "ResearchStudy.description",
"short": "What this is study doing",
"definition": "A full description of how the study is being conducted.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Detailed Description"
}
]
},
{
"id": "ResearchStudy.enrollment",
"path": "ResearchStudy.enrollment",
"short": "Inclusion & exclusion criteria",
"definition": "Reference to a Group that defines the criteria for and quantity of subjects participating in the study. E.g. \" 200 female Europeans between the ages of 20 and 45 with early onset diabetes\".",
"comment": "The Group referenced should not generally enumerate specific subjects. Subjects will be linked to the study using the ResearchSubject resource.",
"alias": [
"patient"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Enrollment; Number of Groups/Cohorts (= number of \"enrollment\" instances); Groups (Group/Cohort Label = Group.name; Group/Cohort Description = Group.description); Eligibility (Group criteria)"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "ResearchStudy.period",
"path": "ResearchStudy.period",
"short": "When the study began and ended",
"definition": "Identifies the start date and the expected (or actual, depending on status) end date for the study.",
"requirements": "[The list of types may be constrained as appropriate for the type of event].",
"alias": [
"timing"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Study Start Date (start); Study Completion Date (end)"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "ResearchStudy.sponsor",
"path": "ResearchStudy.sponsor",
"short": "Organization responsible for the study",
"definition": "The organization responsible for the execution of the study.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Sponsor"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "ResearchStudy.principalInvestigator",
"path": "ResearchStudy.principalInvestigator",
"short": "The individual responsible for the study",
"definition": "Indicates the individual who has primary oversite of the execution of the study.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Principal Investigator"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "ResearchStudy.site",
"path": "ResearchStudy.site",
"short": "Location involved in study execution",
"definition": "Clinic, hospital or other healthcare location that is participating in the study.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Facility"
},
{
"identity": "w5",
"map": "where"
}
]
},
{
"id": "ResearchStudy.reasonStopped",
"path": "ResearchStudy.reasonStopped",
"short": "Reason for terminating study early",
"definition": "A description and/or code explaining the premature termination of the study.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Why Study Stopped"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ResearchStudy.note",
"path": "ResearchStudy.note",
"short": "Comments made about the event",
"definition": "Comments made about the event by the performer, subject or other participants.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
]
},
{
"id": "ResearchStudy.arm",
"path": "ResearchStudy.arm",
"short": "Defined path through the study for a subject",
"definition": "Describes an expected sequence of events for one of the participants of a study. E.g. Exposure to drug A, wash-out, exposure to drug B, wash-out, follow-up.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Arms"
}
]
},
{
"id": "ResearchStudy.arm.name",
"path": "ResearchStudy.arm.name",
"short": "Label for study arm",
"definition": "Unique, human-readable label for this arm of the study.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Arm Label"
}
]
},
{
"id": "ResearchStudy.arm.code",
"path": "ResearchStudy.arm.code",
"short": "Categorization of study arm",
"definition": "Categorization of study arm, e.g. experimental, active comparator, placebo comparater.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Arm Type"
}
]
},
{
"id": "ResearchStudy.arm.description",
"path": "ResearchStudy.arm.description",
"short": "Short explanation of study path",
"definition": "A succinct description of the path through the study that would be followed by a subject adhering to this arm.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "clinicaltrials-gov",
"map": "Arm Description"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/ResearchSubject",
"resource": {
"resourceType": "StructureDefinition",
"id": "ResearchSubject",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints ResearchSubject DomainResource Investigation to increase healthcare-related patient-independent knowledge
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..1 Identifier Business Identifier for research subject status ?!Σ 1..1 code candidate | enrolled | active | suspended | withdrawn | completed
ResearchSubjectStatus (Required) period Σ 0..1 Period Start and end of participation study Σ 1..1 Reference(ResearchStudy) Study subject is part of individual Σ 1..1 Reference(Patient) Who is part of study assignedArm 0..1 string What path should be followed actualArm 0..1 string What path was followed consent 0..1 Reference(Consent) Agreement to participate in study
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 0
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "rcrim"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/ResearchSubject",
"name": "ResearchSubject",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Regulated Clinical Research Information Management)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/rcrim/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for ResearchSubject Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "ResearchSubject",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "ResearchSubject",
"path": "ResearchSubject",
"short": "Investigation to increase healthcare-related patient-independent knowledge",
"definition": "A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge. This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques. A ResearchStudy involves the gathering of information about human or animal subjects.",
"comment": "Need to make sure we encompass public health studies.",
"alias": [
"Study Subject"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "v2",
"map": "OBX"
},
{
"identity": "rim",
"map": "Observation[classCode=CLNTRL, moodCode=EVN]"
},
{
"identity": "w5",
"map": "clinical.diagnostics"
}
]
},
{
"id": "ResearchSubject.id",
"path": "ResearchSubject.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "ResearchSubject.meta",
"path": "ResearchSubject.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "ResearchSubject.implicitRules",
"path": "ResearchSubject.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "ResearchSubject.language",
"path": "ResearchSubject.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "ResearchSubject.text",
"path": "ResearchSubject.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "ResearchSubject.contained",
"path": "ResearchSubject.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ResearchSubject.extension",
"path": "ResearchSubject.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ResearchSubject.modifierExtension",
"path": "ResearchSubject.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ResearchSubject.identifier",
"path": "ResearchSubject.identifier",
"short": "Business Identifier for research subject",
"definition": "Identifiers assigned to this research study by the sponsor or other systems.",
"requirements": "Allows identification of the research study as it is known by various participating systems and in a way that remains consistent across servers.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ResearchSubject.status",
"path": "ResearchSubject.status",
"short": "candidate | enrolled | active | suspended | withdrawn | completed",
"definition": "The current state of the subject.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResearchSubjectStatus"
}
],
"strength": "required",
"description": "Indicates the progression of a study subject through a study",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/research-subject-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ResearchSubject.period",
"path": "ResearchSubject.period",
"short": "Start and end of participation",
"definition": "The dates the subject began and ended their participation in the study.",
"alias": [
"timing"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "ResearchSubject.study",
"path": "ResearchSubject.study",
"short": "Study subject is part of",
"definition": "Reference to the study the subject is participating in.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ResearchStudy"
}
],
"isSummary": true
},
{
"id": "ResearchSubject.individual",
"path": "ResearchSubject.individual",
"short": "Who is part of study",
"definition": "The record of the person or animal who is involved in the study.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"isSummary": true
},
{
"id": "ResearchSubject.assignedArm",
"path": "ResearchSubject.assignedArm",
"short": "What path should be followed",
"definition": "The name of the arm in the study the subject is expected to follow as part of this study.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ResearchSubject.actualArm",
"path": "ResearchSubject.actualArm",
"short": "What path was followed",
"definition": "The name of the arm in the study the subject actually followed as part of this study.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ResearchSubject.consent",
"path": "ResearchSubject.consent",
"short": "Agreement to participate in study",
"definition": "A record of the patient's informed agreement to participate in the study.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Consent"
}
]
}
]
},
"differential": {
"element": [
{
"id": "ResearchSubject",
"path": "ResearchSubject",
"short": "Investigation to increase healthcare-related patient-independent knowledge",
"definition": "A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge. This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques. A ResearchStudy involves the gathering of information about human or animal subjects.",
"comment": "Need to make sure we encompass public health studies.",
"alias": [
"Study Subject"
],
"min": 0,
"max": "*",
"mapping": [
{
"identity": "v2",
"map": "OBX"
},
{
"identity": "rim",
"map": "Observation[classCode=CLNTRL, moodCode=EVN]"
},
{
"identity": "w5",
"map": "clinical.diagnostics"
}
]
},
{
"id": "ResearchSubject.identifier",
"path": "ResearchSubject.identifier",
"short": "Business Identifier for research subject",
"definition": "Identifiers assigned to this research study by the sponsor or other systems.",
"requirements": "Allows identification of the research study as it is known by various participating systems and in a way that remains consistent across servers.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ResearchSubject.status",
"path": "ResearchSubject.status",
"short": "candidate | enrolled | active | suspended | withdrawn | completed",
"definition": "The current state of the subject.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResearchSubjectStatus"
}
],
"strength": "required",
"description": "Indicates the progression of a study subject through a study",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/research-subject-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ResearchSubject.period",
"path": "ResearchSubject.period",
"short": "Start and end of participation",
"definition": "The dates the subject began and ended their participation in the study.",
"alias": [
"timing"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "ResearchSubject.study",
"path": "ResearchSubject.study",
"short": "Study subject is part of",
"definition": "Reference to the study the subject is participating in.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ResearchStudy"
}
],
"isSummary": true
},
{
"id": "ResearchSubject.individual",
"path": "ResearchSubject.individual",
"short": "Who is part of study",
"definition": "The record of the person or animal who is involved in the study.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"isSummary": true
},
{
"id": "ResearchSubject.assignedArm",
"path": "ResearchSubject.assignedArm",
"short": "What path should be followed",
"definition": "The name of the arm in the study the subject is expected to follow as part of this study.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ResearchSubject.actualArm",
"path": "ResearchSubject.actualArm",
"short": "What path was followed",
"definition": "The name of the arm in the study the subject actually followed as part of this study.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ResearchSubject.consent",
"path": "ResearchSubject.consent",
"short": "Agreement to participate in study",
"definition": "A record of the patient's informed agreement to participate in the study.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Consent"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/RiskAssessment",
"resource": {
"resourceType": "StructureDefinition",
"id": "RiskAssessment",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints RiskAssessment DomainResource Potential outcomes for a subject with likelihood
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..1 Identifier Unique identifier for the assessment basedOn 0..1 Reference(Any) Request fulfilled by this assessment parent 0..1 Reference(Any) Part of this occurrence status 1..1 code registered | preliminary | final | amended +
ObservationStatus (Required) method Σ 0..1 CodeableConcept Evaluation mechanism code Σ 0..1 CodeableConcept Type of assessment subject Σ 0..1 Reference(Patient | Group) Who/what does assessment apply to? context Σ 0..1 Reference(Encounter | EpisodeOfCare) Where was assessment performed? occurrence[x] Σ 0..1 When was assessment made? occurrenceDateTime dateTime occurrencePeriod Period condition Σ 0..1 Reference(Condition) Condition assessed performer Σ 0..1 Reference(Practitioner | Device) Who did assessment? reason[x] 0..1 Why the assessment was necessary? reasonCodeableConcept CodeableConcept reasonReference Reference(Any) basis 0..* Reference(Any) Information used in assessment
prediction I 0..* BackboneElement Outcome predicted
+ Must be <= 100
outcome 1..1 CodeableConcept Possible outcome for the subject probability[x] I 0..1 Likelihood of specified outcome
+ low and high must be percentages, if present probabilityDecimal decimal probabilityRange Range qualitativeRisk 0..1 CodeableConcept Likelihood of specified outcome as a qualitative value
Risk Probability (Example) relativeRisk 0..1 decimal Relative likelihood when[x] 0..1 Timeframe or age range whenPeriod Period whenRange Range rationale 0..1 string Explanation of prediction mitigation 0..1 string How to reduce risk comment 0..1 string Comments on the risk assessment
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 1
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "cds"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/RiskAssessment",
"name": "RiskAssessment",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Clinical Decision Support)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/dss/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for RiskAssessment Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "openehr",
"uri": "http://openehr.org",
"name": "Open EHR Archetype Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "RiskAssessment",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "RiskAssessment",
"path": "RiskAssessment",
"short": "Potential outcomes for a subject with likelihood",
"definition": "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome.",
"alias": [
"Prognosis"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "Observation[classCode=OBS, moodCode=EVN, code=\"Risk Assessment\"]"
},
{
"identity": "openehr",
"map": "OpenEHR-EHR-EVALUATION.risk.v1"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "RiskAssessment.id",
"path": "RiskAssessment.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "RiskAssessment.meta",
"path": "RiskAssessment.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "RiskAssessment.implicitRules",
"path": "RiskAssessment.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "RiskAssessment.language",
"path": "RiskAssessment.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "RiskAssessment.text",
"path": "RiskAssessment.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "RiskAssessment.contained",
"path": "RiskAssessment.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RiskAssessment.extension",
"path": "RiskAssessment.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RiskAssessment.modifierExtension",
"path": "RiskAssessment.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RiskAssessment.identifier",
"path": "RiskAssessment.identifier",
"short": "Unique identifier for the assessment",
"definition": "Business identifier assigned to the risk assessment.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "openehr",
"map": "Workflow Identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "RiskAssessment.basedOn",
"path": "RiskAssessment.basedOn",
"short": "Request fulfilled by this assessment",
"definition": "A reference to the request that is fulfilled by this risk assessment.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.basedOn"
}
]
},
{
"id": "RiskAssessment.parent",
"path": "RiskAssessment.parent",
"short": "Part of this occurrence",
"definition": "A reference to a resource that this risk assessment is part of, such as a Procedure.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.partOf"
}
]
},
{
"id": "RiskAssessment.status",
"path": "RiskAssessment.status",
"short": "registered | preliminary | final | amended +",
"definition": "The status of the RiskAssessment, using the same statuses as an Observation.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RiskAssessmentStatus"
}
],
"strength": "required",
"description": "The status of the risk assessment; e.g. preliminary, final, amended, etc.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "RiskAssessment.method",
"path": "RiskAssessment.method",
"short": "Evaluation mechanism",
"definition": "The algorithm, process or mechanism used to evaluate the risk.",
"requirements": "The method can influence the results of the assessment.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RiskAssessmentMethod"
}
],
"strength": "example",
"description": "The mechanism or algorithm used to make the assessment; e.g. TIMI, PRISM, Cardiff Type 2 diabetes, etc."
},
"mapping": [
{
"identity": "rim",
"map": ".methodCode"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "RiskAssessment.code",
"path": "RiskAssessment.code",
"short": "Type of assessment",
"definition": "The type of the risk assessment performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "RiskAssessment.subject",
"path": "RiskAssessment.subject",
"short": "Who/what does assessment apply to?",
"definition": "The patient or group the risk assessment applies to.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.subject"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
},
{
"identity": "openehr",
"map": "Subject of Care"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "RiskAssessment.context",
"path": "RiskAssessment.context",
"short": "Where was assessment performed?",
"definition": "The encounter where the assessment was performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.context"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "RiskAssessment.occurrence[x]",
"path": "RiskAssessment.occurrence[x]",
"short": "When was assessment made?",
"definition": "The date (and possibly time) the risk assessment was performed.",
"requirements": "The assessment results lose validity the more time elapses from when they are first made.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "RiskAssessment.condition",
"path": "RiskAssessment.condition",
"short": "Condition assessed",
"definition": "For assessments or prognosis specific to a particular condition, indicates the condition being assessed.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=SUBJ].target[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "RiskAssessment.performer",
"path": "RiskAssessment.performer",
"short": "Who did assessment?",
"definition": "The provider or software application that performed the assessment.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.actor"
},
{
"identity": "rim",
"map": ".participation[typeCode=PFM].role[classCode=ASSIGNED]"
},
{
"identity": "openehr",
"map": "Information Provider"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "RiskAssessment.reason[x]",
"path": "RiskAssessment.reason[x]",
"short": "Why the assessment was necessary?",
"definition": "The reason the risk assessment was performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.reason"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "RiskAssessment.basis",
"path": "RiskAssessment.basis",
"short": "Information used in assessment",
"definition": "Indicates the source data considered as part of the assessment (FamilyHistory, Observations, Procedures, Conditions, etc.).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.reasonReference"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DRIV].target"
},
{
"identity": "openehr",
"map": "Risk Factor; Link to Evidence"
}
]
},
{
"id": "RiskAssessment.prediction",
"path": "RiskAssessment.prediction",
"short": "Outcome predicted",
"definition": "Describes the expected outcome for the subject.",
"comment": "Multiple repetitions can be used to identify the same type of outcome in different timeframes as well as different types of outcomes.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "ras-2",
"severity": "error",
"human": "Must be <= 100",
"expression": "probability is decimal implies probability.as(decimal) <= 100",
"xpath": "not(f:probabilityDecimal) or f:probabilityDecimal/@value <= 100"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=VALUE].target[classCod=OBS, moodCode=RISK]"
}
]
},
{
"id": "RiskAssessment.prediction.id",
"path": "RiskAssessment.prediction.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "RiskAssessment.prediction.extension",
"path": "RiskAssessment.prediction.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "RiskAssessment.prediction.modifierExtension",
"path": "RiskAssessment.prediction.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "RiskAssessment.prediction.outcome",
"path": "RiskAssessment.prediction.outcome",
"short": "Possible outcome for the subject",
"definition": "One of the potential outcomes for the patient (e.g. remission, death, a particular condition).",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RiskAssessmentOutcome"
}
],
"strength": "example",
"description": "The condition or other outcome; e.g. death, remission, amputation, infection, etc."
},
"mapping": [
{
"identity": "rim",
"map": ".value"
},
{
"identity": "openehr",
"map": "Risk"
}
]
},
{
"id": "RiskAssessment.prediction.probability[x]",
"path": "RiskAssessment.prediction.probability[x]",
"short": "Likelihood of specified outcome",
"definition": "How likely is the outcome (in the specified timeframe).",
"comment": "If range is used, it represents the lower and upper bounds of certainty; e.g. 40-60% Decimal values are expressed as percentages as well (max = 100).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
},
{
"code": "Range"
}
],
"constraint": [
{
"key": "ras-1",
"severity": "error",
"human": "low and high must be percentages, if present",
"expression": "(low.empty() or ((low.code = '%') and (low.system = %ucum))) and (high.empty() or ((high.code = '%') and (high.system = %ucum)))",
"xpath": "(not(f:low) or f:low[f:code/@value='%' and f:system/@value='http://unitsofmeasure.org']) and (not(f:high) or f:high[f:code/@value='%' and f:system/@value='http://unitsofmeasure.org'])"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"probability\"].value"
},
{
"identity": "openehr",
"map": "Category"
}
]
},
{
"id": "RiskAssessment.prediction.qualitativeRisk",
"path": "RiskAssessment.prediction.qualitativeRisk",
"short": "Likelihood of specified outcome as a qualitative value",
"definition": "How likely is the outcome (in the specified timeframe), expressed as a qualitative value (e.g. low, medium, high).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RiskAssessmentProbability"
}
],
"strength": "example",
"description": "The likelihood of the occurrence of a specified outcome",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/risk-probability"
}
}
},
{
"id": "RiskAssessment.prediction.relativeRisk",
"path": "RiskAssessment.prediction.relativeRisk",
"short": "Relative likelihood",
"definition": "Indicates the risk for this particular subject (with their specific characteristics) divided by the risk of the population in general. (Numbers greater than 1 = higher risk than the population, numbers less than 1 = lower risk.).",
"requirements": "Absolute risk is less meaningful than relative risk.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"relative risk\"].value"
}
]
},
{
"id": "RiskAssessment.prediction.when[x]",
"path": "RiskAssessment.prediction.when[x]",
"short": "Timeframe or age range",
"definition": "Indicates the period of time or age range of the subject to which the specified probability applies.",
"comment": "If not specified, the risk applies \"over the subject's lifespan\".",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
},
{
"code": "Range"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime or .inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"age\"].value"
}
]
},
{
"id": "RiskAssessment.prediction.rationale",
"path": "RiskAssessment.prediction.rationale",
"short": "Explanation of prediction",
"definition": "Additional information explaining the basis for the prediction.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".reasonCode.text"
},
{
"identity": "openehr",
"map": "Rationale"
}
]
},
{
"id": "RiskAssessment.mitigation",
"path": "RiskAssessment.mitigation",
"short": "How to reduce risk",
"definition": "A description of the steps that might be taken to reduce the identified risk(s).",
"requirements": "One of the main reasons for assessing risks is to identify whether interventional steps are needed to reduce risk.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=MTGT].target[classCode=ACT, moodCode=EVN].text"
}
]
},
{
"id": "RiskAssessment.comment",
"path": "RiskAssessment.comment",
"short": "Comments on the risk assessment",
"definition": "Additional comments about the risk assessment.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.note"
}
]
}
]
},
"differential": {
"element": [
{
"id": "RiskAssessment",
"path": "RiskAssessment",
"short": "Potential outcomes for a subject with likelihood",
"definition": "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome.",
"alias": [
"Prognosis"
],
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": "Observation[classCode=OBS, moodCode=EVN, code=\"Risk Assessment\"]"
},
{
"identity": "openehr",
"map": "OpenEHR-EHR-EVALUATION.risk.v1"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "RiskAssessment.identifier",
"path": "RiskAssessment.identifier",
"short": "Unique identifier for the assessment",
"definition": "Business identifier assigned to the risk assessment.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "openehr",
"map": "Workflow Identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "RiskAssessment.basedOn",
"path": "RiskAssessment.basedOn",
"short": "Request fulfilled by this assessment",
"definition": "A reference to the request that is fulfilled by this risk assessment.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.basedOn"
}
]
},
{
"id": "RiskAssessment.parent",
"path": "RiskAssessment.parent",
"short": "Part of this occurrence",
"definition": "A reference to a resource that this risk assessment is part of, such as a Procedure.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.partOf"
}
]
},
{
"id": "RiskAssessment.status",
"path": "RiskAssessment.status",
"short": "registered | preliminary | final | amended +",
"definition": "The status of the RiskAssessment, using the same statuses as an Observation.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RiskAssessmentStatus"
}
],
"strength": "required",
"description": "The status of the risk assessment; e.g. preliminary, final, amended, etc.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/observation-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "RiskAssessment.method",
"path": "RiskAssessment.method",
"short": "Evaluation mechanism",
"definition": "The algorithm, process or mechanism used to evaluate the risk.",
"requirements": "The method can influence the results of the assessment.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RiskAssessmentMethod"
}
],
"strength": "example",
"description": "The mechanism or algorithm used to make the assessment; e.g. TIMI, PRISM, Cardiff Type 2 diabetes, etc."
},
"mapping": [
{
"identity": "rim",
"map": ".methodCode"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "RiskAssessment.code",
"path": "RiskAssessment.code",
"short": "Type of assessment",
"definition": "The type of the risk assessment performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "RiskAssessment.subject",
"path": "RiskAssessment.subject",
"short": "Who/what does assessment apply to?",
"definition": "The patient or group the risk assessment applies to.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.subject"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
},
{
"identity": "openehr",
"map": "Subject of Care"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "RiskAssessment.context",
"path": "RiskAssessment.context",
"short": "Where was assessment performed?",
"definition": "The encounter where the assessment was performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.context"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "RiskAssessment.occurrence[x]",
"path": "RiskAssessment.occurrence[x]",
"short": "When was assessment made?",
"definition": "The date (and possibly time) the risk assessment was performed.",
"requirements": "The assessment results lose validity the more time elapses from when they are first made.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "RiskAssessment.condition",
"path": "RiskAssessment.condition",
"short": "Condition assessed",
"definition": "For assessments or prognosis specific to a particular condition, indicates the condition being assessed.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=SUBJ].target[classCode=OBS, moodCode=EVN]"
}
]
},
{
"id": "RiskAssessment.performer",
"path": "RiskAssessment.performer",
"short": "Who did assessment?",
"definition": "The provider or software application that performed the assessment.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.actor"
},
{
"identity": "rim",
"map": ".participation[typeCode=PFM].role[classCode=ASSIGNED]"
},
{
"identity": "openehr",
"map": "Information Provider"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "RiskAssessment.reason[x]",
"path": "RiskAssessment.reason[x]",
"short": "Why the assessment was necessary?",
"definition": "The reason the risk assessment was performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.reason"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "RiskAssessment.basis",
"path": "RiskAssessment.basis",
"short": "Information used in assessment",
"definition": "Indicates the source data considered as part of the assessment (FamilyHistory, Observations, Procedures, Conditions, etc.).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.reasonReference"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DRIV].target"
},
{
"identity": "openehr",
"map": "Risk Factor; Link to Evidence"
}
]
},
{
"id": "RiskAssessment.prediction",
"path": "RiskAssessment.prediction",
"short": "Outcome predicted",
"definition": "Describes the expected outcome for the subject.",
"comment": "Multiple repetitions can be used to identify the same type of outcome in different timeframes as well as different types of outcomes.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ras-2",
"severity": "error",
"human": "Must be <= 100",
"expression": "probability is decimal implies probability.as(decimal) <= 100",
"xpath": "not(f:probabilityDecimal) or f:probabilityDecimal/@value <= 100"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=VALUE].target[classCod=OBS, moodCode=RISK]"
}
]
},
{
"id": "RiskAssessment.prediction.outcome",
"path": "RiskAssessment.prediction.outcome",
"short": "Possible outcome for the subject",
"definition": "One of the potential outcomes for the patient (e.g. remission, death, a particular condition).",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RiskAssessmentOutcome"
}
],
"strength": "example",
"description": "The condition or other outcome; e.g. death, remission, amputation, infection, etc."
},
"mapping": [
{
"identity": "rim",
"map": ".value"
},
{
"identity": "openehr",
"map": "Risk"
}
]
},
{
"id": "RiskAssessment.prediction.probability[x]",
"path": "RiskAssessment.prediction.probability[x]",
"short": "Likelihood of specified outcome",
"definition": "How likely is the outcome (in the specified timeframe).",
"comment": "If range is used, it represents the lower and upper bounds of certainty; e.g. 40-60% Decimal values are expressed as percentages as well (max = 100).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
},
{
"code": "Range"
}
],
"constraint": [
{
"key": "ras-1",
"severity": "error",
"human": "low and high must be percentages, if present",
"expression": "(low.empty() or ((low.code = '%') and (low.system = %ucum))) and (high.empty() or ((high.code = '%') and (high.system = %ucum)))",
"xpath": "(not(f:low) or f:low[f:code/@value='%' and f:system/@value='http://unitsofmeasure.org']) and (not(f:high) or f:high[f:code/@value='%' and f:system/@value='http://unitsofmeasure.org'])"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"probability\"].value"
},
{
"identity": "openehr",
"map": "Category"
}
]
},
{
"id": "RiskAssessment.prediction.qualitativeRisk",
"path": "RiskAssessment.prediction.qualitativeRisk",
"short": "Likelihood of specified outcome as a qualitative value",
"definition": "How likely is the outcome (in the specified timeframe), expressed as a qualitative value (e.g. low, medium, high).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RiskAssessmentProbability"
}
],
"strength": "example",
"description": "The likelihood of the occurrence of a specified outcome",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/risk-probability"
}
}
},
{
"id": "RiskAssessment.prediction.relativeRisk",
"path": "RiskAssessment.prediction.relativeRisk",
"short": "Relative likelihood",
"definition": "Indicates the risk for this particular subject (with their specific characteristics) divided by the risk of the population in general. (Numbers greater than 1 = higher risk than the population, numbers less than 1 = lower risk.).",
"requirements": "Absolute risk is less meaningful than relative risk.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"relative risk\"].value"
}
]
},
{
"id": "RiskAssessment.prediction.when[x]",
"path": "RiskAssessment.prediction.when[x]",
"short": "Timeframe or age range",
"definition": "Indicates the period of time or age range of the subject to which the specified probability applies.",
"comment": "If not specified, the risk applies \"over the subject's lifespan\".",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
},
{
"code": "Range"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime or .inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"age\"].value"
}
]
},
{
"id": "RiskAssessment.prediction.rationale",
"path": "RiskAssessment.prediction.rationale",
"short": "Explanation of prediction",
"definition": "Additional information explaining the basis for the prediction.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".reasonCode.text"
},
{
"identity": "openehr",
"map": "Rationale"
}
]
},
{
"id": "RiskAssessment.mitigation",
"path": "RiskAssessment.mitigation",
"short": "How to reduce risk",
"definition": "A description of the steps that might be taken to reduce the identified risk(s).",
"requirements": "One of the main reasons for assessing risks is to identify whether interventional steps are needed to reduce risk.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=MTGT].target[classCode=ACT, moodCode=EVN].text"
}
]
},
{
"id": "RiskAssessment.comment",
"path": "RiskAssessment.comment",
"short": "Comments on the risk assessment",
"definition": "Additional comments about the risk assessment.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.note"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Schedule",
"resource": {
"resourceType": "StructureDefinition",
"id": "Schedule",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Schedule DomainResource A container for slots of time that may be available for booking appointments
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier External Ids for this item
active ?!Σ 0..1 boolean Whether this schedule is in active use serviceCategory Σ 0..1 CodeableConcept A broad categorisation of the service that is to be performed during this appointment
ServiceCategory (Example) serviceType Σ 0..* CodeableConcept The specific service that is to be performed during this appointment
ServiceType (Example)
specialty Σ 0..* CodeableConcept The specialty of a practitioner that would be required to perform the service requested in this appointment
Practice Setting Code Value Set (Preferred)
actor Σ 1..* Reference(Patient | Practitioner | PractitionerRole | RelatedPerson | Device | HealthcareService | Location) The resource this Schedule resource is providing availability information for. These are expected to usually be one of HealthcareService, Location, Practitioner, PractitionerRole, Device, Patient or RelatedPerson
planningHorizon Σ 0..1 Period The period of time that the slots that are attached to this Schedule resource cover (even if none exist). These cover the amount of time that an organization's planning horizon; the interval for which they are currently accepting appointments. This does not define a "template" for planning outside these dates comment 0..1 string Comments on the availability to describe any extended information. Such as custom constraints on the slots that may be associated
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "pa"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Schedule",
"name": "Schedule",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Patient Administration)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/pafm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Schedule Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "ical",
"uri": "http://www.ietf.org/rfc/rfc2445.txt",
"name": "iCalendar"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Schedule",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Schedule",
"path": "Schedule",
"short": "A container for slots of time that may be available for booking appointments",
"definition": "A container for slots of time that may be available for booking appointments.",
"alias": [
"Availability"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "ical",
"map": "BEGIN:VFREEBUSY ??? END:VFREEBUSY (If your fhir server provides this information via calDAV, then you may want to include addressing information in a URL section, and with the search, a DTSTART and DTEND component can be included to indicate the range of time that has been covered in the collection of slots, where these overlap the resources period values. For all slots that reference this resource, include a FREEBUSY row for each slot)"
},
{
"identity": "w5",
"map": "workflow.scheduling"
}
]
},
{
"id": "Schedule.id",
"path": "Schedule.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Schedule.meta",
"path": "Schedule.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Schedule.implicitRules",
"path": "Schedule.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Schedule.language",
"path": "Schedule.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Schedule.text",
"path": "Schedule.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Schedule.contained",
"path": "Schedule.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Schedule.extension",
"path": "Schedule.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Schedule.modifierExtension",
"path": "Schedule.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Schedule.identifier",
"path": "Schedule.identifier",
"short": "External Ids for this item",
"definition": "External Ids for this item.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "ical",
"map": "UID"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Schedule.active",
"path": "Schedule.active",
"short": "Whether this schedule is in active use",
"definition": "Whether this schedule record is in active use, or should not be used (such as was entered in error).",
"comment": "This element is labeled as a modifier because it may be used to mark that the resource was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Schedule.serviceCategory",
"path": "Schedule.serviceCategory",
"short": "A broad categorisation of the service that is to be performed during this appointment",
"definition": "A broad categorisation of the service that is to be performed during this appointment.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "service-category"
}
],
"strength": "example",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/service-category"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Schedule.serviceType",
"path": "Schedule.serviceType",
"short": "The specific service that is to be performed during this appointment",
"definition": "The specific service that is to be performed during this appointment.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "service-type"
}
],
"strength": "example",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/service-type"
}
},
"mapping": [
{
"identity": "ical",
"map": "n/a"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Schedule.specialty",
"path": "Schedule.specialty",
"short": "The specialty of a practitioner that would be required to perform the service requested in this appointment",
"definition": "The specialty of a practitioner that would be required to perform the service requested in this appointment.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "specialty"
}
],
"strength": "preferred",
"description": "Additional details about where the content was created (e.g. clinical specialty)",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/c80-practice-codes"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Schedule.actor",
"path": "Schedule.actor",
"short": "The resource this Schedule resource is providing availability information for. These are expected to usually be one of HealthcareService, Location, Practitioner, PractitionerRole, Device, Patient or RelatedPerson",
"definition": "The resource this Schedule resource is providing availability information for. These are expected to usually be one of HealthcareService, Location, Practitioner, PractitionerRole, Device, Patient or RelatedPerson.",
"comment": "The capacity to support multiple referenced resource types should be used in cases where the specific resources themselves cannot be scheduled without the other, and thus only make sense to the system exposing them as a group. Common examples of this are where the combination of a pracitioner and a room(location) are always required by a system.",
"min": 1,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PractitionerRole"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/HealthcareService"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"isSummary": true,
"mapping": [
{
"identity": "ical",
"map": "ATTENDEE:MAILTO:john_public@host2.com This can be populated with a value from the referenced resource"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Schedule.planningHorizon",
"path": "Schedule.planningHorizon",
"short": "The period of time that the slots that are attached to this Schedule resource cover (even if none exist). These cover the amount of time that an organization's planning horizon; the interval for which they are currently accepting appointments. This does not define a \"template\" for planning outside these dates",
"definition": "The period of time that the slots that are attached to this Schedule resource cover (even if none exist). These cover the amount of time that an organization's planning horizon; the interval for which they are currently accepting appointments. This does not define a \"template\" for planning outside these dates.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "ical",
"map": "DTSTART:20131201T003000Z DTEND:2014030101T003000Z"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "Schedule.comment",
"path": "Schedule.comment",
"short": "Comments on the availability to describe any extended information. Such as custom constraints on the slots that may be associated",
"definition": "Comments on the availability to describe any extended information. Such as custom constraints on the slots that may be associated.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "ical",
"map": "COMMENT:(comment) If there is no comment, then the line can be excluded from the iCalendar entry"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Schedule",
"path": "Schedule",
"short": "A container for slots of time that may be available for booking appointments",
"definition": "A container for slots of time that may be available for booking appointments.",
"alias": [
"Availability"
],
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "ical",
"map": "BEGIN:VFREEBUSY ??? END:VFREEBUSY (If your fhir server provides this information via calDAV, then you may want to include addressing information in a URL section, and with the search, a DTSTART and DTEND component can be included to indicate the range of time that has been covered in the collection of slots, where these overlap the resources period values. For all slots that reference this resource, include a FREEBUSY row for each slot)"
},
{
"identity": "w5",
"map": "workflow.scheduling"
}
]
},
{
"id": "Schedule.identifier",
"path": "Schedule.identifier",
"short": "External Ids for this item",
"definition": "External Ids for this item.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "ical",
"map": "UID"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Schedule.active",
"path": "Schedule.active",
"short": "Whether this schedule is in active use",
"definition": "Whether this schedule record is in active use, or should not be used (such as was entered in error).",
"comment": "This element is labeled as a modifier because it may be used to mark that the resource was created in error.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true,
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Schedule.serviceCategory",
"path": "Schedule.serviceCategory",
"short": "A broad categorisation of the service that is to be performed during this appointment",
"definition": "A broad categorisation of the service that is to be performed during this appointment.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "service-category"
}
],
"strength": "example",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/service-category"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Schedule.serviceType",
"path": "Schedule.serviceType",
"short": "The specific service that is to be performed during this appointment",
"definition": "The specific service that is to be performed during this appointment.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "service-type"
}
],
"strength": "example",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/service-type"
}
},
"mapping": [
{
"identity": "ical",
"map": "n/a"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Schedule.specialty",
"path": "Schedule.specialty",
"short": "The specialty of a practitioner that would be required to perform the service requested in this appointment",
"definition": "The specialty of a practitioner that would be required to perform the service requested in this appointment.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "specialty"
}
],
"strength": "preferred",
"description": "Additional details about where the content was created (e.g. clinical specialty)",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/c80-practice-codes"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Schedule.actor",
"path": "Schedule.actor",
"short": "The resource this Schedule resource is providing availability information for. These are expected to usually be one of HealthcareService, Location, Practitioner, PractitionerRole, Device, Patient or RelatedPerson",
"definition": "The resource this Schedule resource is providing availability information for. These are expected to usually be one of HealthcareService, Location, Practitioner, PractitionerRole, Device, Patient or RelatedPerson.",
"comment": "The capacity to support multiple referenced resource types should be used in cases where the specific resources themselves cannot be scheduled without the other, and thus only make sense to the system exposing them as a group. Common examples of this are where the combination of a pracitioner and a room(location) are always required by a system.",
"min": 1,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/PractitionerRole"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/HealthcareService"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"isSummary": true,
"mapping": [
{
"identity": "ical",
"map": "ATTENDEE:MAILTO:john_public@host2.com This can be populated with a value from the referenced resource"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Schedule.planningHorizon",
"path": "Schedule.planningHorizon",
"short": "The period of time that the slots that are attached to this Schedule resource cover (even if none exist). These cover the amount of time that an organization's planning horizon; the interval for which they are currently accepting appointments. This does not define a \"template\" for planning outside these dates",
"definition": "The period of time that the slots that are attached to this Schedule resource cover (even if none exist). These cover the amount of time that an organization's planning horizon; the interval for which they are currently accepting appointments. This does not define a \"template\" for planning outside these dates.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "ical",
"map": "DTSTART:20131201T003000Z DTEND:2014030101T003000Z"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "Schedule.comment",
"path": "Schedule.comment",
"short": "Comments on the availability to describe any extended information. Such as custom constraints on the slots that may be associated",
"definition": "Comments on the availability to describe any extended information. Such as custom constraints on the slots that may be associated.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "ical",
"map": "COMMENT:(comment) If there is no comment, then the line can be excluded from the iCalendar entry"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/SearchParameter",
"resource": {
"resourceType": "StructureDefinition",
"id": "SearchParameter",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints SearchParameter I DomainResource Search Parameter for a resource
+ If an xpath is present, there SHALL be an xpathUsage
+ Search parameters can only have chain names when the search parameter type is 'reference'
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension url Σ 1..1 uri Logical URI to reference this search parameter (globally unique) version Σ 0..1 string Business version of the search parameter name Σ 1..1 string Name for this search parameter (computer friendly) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) experimental ?!Σ 0..1 boolean For testing purposes, not real usage date Σ 0..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) contact Σ 0..* ContactDetail Contact details for the publisher
useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for search parameter (if applicable)
Jurisdiction ValueSet (Extensible)
purpose 0..1 markdown Why this search parameter is defined code Σ 1..1 code Code used in URL base Σ 1..* code The resource type(s) this search parameter applies to
ResourceType (Required)
type Σ 1..1 code number | date | string | token | reference | composite | quantity | uri
SearchParamType (Required) derivedFrom 0..1 uri Original Definition for the search parameter description Σ 1..1 markdown Natural language description of the search parameter expression I 0..1 string FHIRPath expression that extracts the values xpath I 0..1 string XPath that extracts the values xpathUsage I 0..1 code normal | phonetic | nearby | distance | other
XPathUsageType (Required) target 0..* code Types of resource (if a resource reference)
ResourceType (Required)
comparator 0..* code eq | ne | gt | lt | ge | le | sa | eb | ap
SearchComparator (Required)
modifier 0..* code missing | exact | contains | not | text | in | not-in | below | above | type
SearchModifierCode (Required)
chain 0..* string Chained names supported
component 0..* BackboneElement For Composite resources to define the parts
definition 1..1 Reference(SearchParameter) Defines how the part works expression 1..1 string Subexpression relative to main expression
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/SearchParameter",
"name": "SearchParameter",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for SearchParameter Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "objimpl",
"uri": "http://hl7.org/fhir/object-implementation",
"name": "Object Implementation Information"
}
],
"kind": "resource",
"abstract": false,
"type": "SearchParameter",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"_baseDefinition": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-codegen-super",
"valueString": "MetadataResource"
}
]
},
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "SearchParameter",
"path": "SearchParameter",
"short": "Search Parameter for a resource",
"definition": "A search parameter that defines a named search item that can be used to search/filter on a resource.",
"comment": "In FHIR, search is not performed directly on a resource (by XML or JSON path), but on a named parameter that maps into the resource content.",
"min": 1,
"max": "1",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "spd-1",
"severity": "error",
"human": "If an xpath is present, there SHALL be an xpathUsage",
"expression": "xpath.empty() or xpathUsage.exists()",
"xpath": "not(exists(f:xpath)) or exists(f:xpathUsage)"
},
{
"key": "spd-2",
"severity": "error",
"human": "Search parameters can only have chain names when the search parameter type is 'reference'",
"expression": "chain.empty() or type = 'reference'",
"xpath": "not(exists(f:chain)) or (f:type/@value = 'reference')"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "v2",
"map": "n/a"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "conformance.behavior"
}
]
},
{
"id": "SearchParameter.id",
"path": "SearchParameter.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "SearchParameter.meta",
"path": "SearchParameter.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "SearchParameter.implicitRules",
"path": "SearchParameter.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "SearchParameter.language",
"path": "SearchParameter.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "SearchParameter.text",
"path": "SearchParameter.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "SearchParameter.contained",
"path": "SearchParameter.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SearchParameter.extension",
"path": "SearchParameter.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SearchParameter.modifierExtension",
"path": "SearchParameter.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SearchParameter.url",
"path": "SearchParameter.url",
"short": "Logical URI to reference this search parameter (globally unique)",
"definition": "An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the search parameter to be referenced by a single globally unique identifier. To allow referencing and reusing search parameter definitions under other names on operational systems (in case of name clash).",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "SearchParameter.version",
"path": "SearchParameter.version",
"short": "Business version of the search parameter",
"definition": "The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different search parameter instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the search parameter with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "SearchParameter.name",
"path": "SearchParameter.name",
"short": "Name for this search parameter (computer friendly)",
"definition": "A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "SearchParameter.status",
"path": "SearchParameter.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this search parameter. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of search parameters that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired search parameter without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "SearchParameter.experimental",
"path": "SearchParameter.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of search parameter that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental search parameter in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level search parameter.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "SearchParameter.date",
"path": "SearchParameter.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the search parameter. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "SearchParameter.publisher",
"path": "SearchParameter.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the search parameter.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the search parameter is the organization or individual primarily responsible for the maintenance and upkeep of the search parameter. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the search parameter. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the search parameter. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "SearchParameter.contact",
"path": "SearchParameter.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "SearchParameter.useContext",
"path": "SearchParameter.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate search parameter instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "SearchParameter.jurisdiction",
"path": "SearchParameter.jurisdiction",
"short": "Intended jurisdiction for search parameter (if applicable)",
"definition": "A legal or geographic region in which the search parameter is intended to be used.",
"comment": "It may be possible for the search parameter to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "SearchParameter.purpose",
"path": "SearchParameter.purpose",
"short": "Why this search parameter is defined",
"definition": "Explaination of why this search parameter is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the search parameter Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this search parameter.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "SearchParameter.code",
"path": "SearchParameter.code",
"short": "Code used in URL",
"definition": "The code used in the URL or the parameter name in a parameters resource for this search parameter.",
"comment": "For maximum compatibility, use only lowercase ASCII characters.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true
},
{
"id": "SearchParameter.base",
"path": "SearchParameter.base",
"short": "The resource type(s) this search parameter applies to",
"definition": "The base resource type(s) that this search parameter can be used against.",
"comment": "A search parameter must always have at least one type. When search parameters have more than one resource, they can be used against any of the listed resource types, or in a cross-type search (see [Cross Resource Search](http.html#xres-search)).",
"min": 1,
"max": "*",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResourceType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "One of the resource types defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/resource-types"
}
}
},
{
"id": "SearchParameter.type",
"path": "SearchParameter.type",
"short": "number | date | string | token | reference | composite | quantity | uri",
"definition": "The type of value a search parameter refers to, and how the content is interpreted.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SearchParamType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Data types allowed to be used for search parameters.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/search-param-type"
}
}
},
{
"id": "SearchParameter.derivedFrom",
"path": "SearchParameter.derivedFrom",
"short": "Original Definition for the search parameter",
"definition": "Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.",
"comment": "The intent of this is that a server can designate that it provides support for a search parameter defined in the specification itself (e.g. [`value-quantity`](http://hl7.org/fhir/SearchParameter/Observation-value-quantity), but detail how it is supported by the server.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "SearchParameter.description",
"path": "SearchParameter.description",
"short": "Natural language description of the search parameter",
"definition": "A free text natural language description of the search parameter from a consumer's perspective. and how it used.",
"comment": "This description can be used to capture details such as why the search parameter was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the search parameter as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 1,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"isSummary": true
},
{
"id": "SearchParameter.expression",
"path": "SearchParameter.expression",
"short": "FHIRPath expression that extracts the values",
"definition": "A FHIRPath expression that returns a set of elements for the search parameter.",
"comment": "Note that the elements returned by the expression are sometimes complex elements where logic is required to determine quite how to handle them; e.g. CodeableConcepts may contain text and/or multiple codings, where the codings themselves contain a code and a system. For composite search parameters, the outcome of the expression must a collection of base elements from which the composites are derived.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"spd-1"
]
},
{
"id": "SearchParameter.xpath",
"path": "SearchParameter.xpath",
"short": "XPath that extracts the values",
"definition": "An XPath expression that returns a set of elements for the search parameter.",
"comment": "Note that the elements returned by the XPath are sometimes complex elements where logic is required to determine quite how to handle them; e.g. CodeableConcepts may contain text and/or multiple codings, where the codings themselves contain a code and a system.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"spd-1"
]
},
{
"id": "SearchParameter.xpathUsage",
"path": "SearchParameter.xpathUsage",
"short": "normal | phonetic | nearby | distance | other",
"definition": "How the search parameter relates to the set of elements returned by evaluating the xpath query.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"spd-1"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "XPathUsageType"
}
],
"strength": "required",
"description": "How a search parameter relates to the set of elements returned by evaluating its xpath query.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/search-xpath-usage"
}
}
},
{
"id": "SearchParameter.target",
"path": "SearchParameter.target",
"short": "Types of resource (if a resource reference)",
"definition": "Types of resource (if a resource is referenced).",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResourceType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "One of the resource types defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/resource-types"
}
}
},
{
"id": "SearchParameter.comparator",
"path": "SearchParameter.comparator",
"short": "eq | ne | gt | lt | ge | le | sa | eb | ap",
"definition": "Comparators supported for the search parameter.",
"comment": "If no comparators are listed, clients should not expect servers to support any comparators.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SearchComparator"
}
],
"strength": "required",
"description": "What Search Comparator Codes are supported in search",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/search-comparator"
}
}
},
{
"id": "SearchParameter.modifier",
"path": "SearchParameter.modifier",
"short": "missing | exact | contains | not | text | in | not-in | below | above | type",
"definition": "A modifier supported for the search parameter.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SearchModifierCode"
}
],
"strength": "required",
"description": "A supported modifier for a search parameter.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/search-modifier-code"
}
}
},
{
"id": "SearchParameter.chain",
"path": "SearchParameter.chain",
"short": "Chained names supported",
"definition": "Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.",
"comment": "Systems are not required to list all the chain names they support, but if they don't list them, clients may not know to use them.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
]
},
{
"id": "SearchParameter.component",
"path": "SearchParameter.component",
"short": "For Composite resources to define the parts",
"definition": "Used to define the parts of a composite search parameter.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "SearchParameter.component.id",
"path": "SearchParameter.component.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "SearchParameter.component.extension",
"path": "SearchParameter.component.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "SearchParameter.component.modifierExtension",
"path": "SearchParameter.component.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SearchParameter.component.definition",
"path": "SearchParameter.component.definition",
"short": "Defines how the part works",
"definition": "The definition of the search parameter that describes this part.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/SearchParameter"
}
]
},
{
"id": "SearchParameter.component.expression",
"path": "SearchParameter.component.expression",
"short": "Subexpression relative to main expression",
"definition": "A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.",
"comment": "This expression overrides the expression in the definition, and extracts the index values from the outcome of the composite expression.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
}
]
},
"differential": {
"element": [
{
"id": "SearchParameter",
"path": "SearchParameter",
"short": "Search Parameter for a resource",
"definition": "A search parameter that defines a named search item that can be used to search/filter on a resource.",
"comment": "In FHIR, search is not performed directly on a resource (by XML or JSON path), but on a named parameter that maps into the resource content.",
"min": 1,
"max": "1",
"constraint": [
{
"key": "spd-1",
"severity": "error",
"human": "If an xpath is present, there SHALL be an xpathUsage",
"expression": "xpath.empty() or xpathUsage.exists()",
"xpath": "not(exists(f:xpath)) or exists(f:xpathUsage)"
},
{
"key": "spd-2",
"severity": "error",
"human": "Search parameters can only have chain names when the search parameter type is 'reference'",
"expression": "chain.empty() or type = 'reference'",
"xpath": "not(exists(f:chain)) or (f:type/@value = 'reference')"
}
],
"mapping": [
{
"identity": "v2",
"map": "n/a"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "conformance.behavior"
}
]
},
{
"id": "SearchParameter.url",
"path": "SearchParameter.url",
"short": "Logical URI to reference this search parameter (globally unique)",
"definition": "An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the search parameter to be referenced by a single globally unique identifier. To allow referencing and reusing search parameter definitions under other names on operational systems (in case of name clash).",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "SearchParameter.version",
"path": "SearchParameter.version",
"short": "Business version of the search parameter",
"definition": "The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different search parameter instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the search parameter with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "SearchParameter.name",
"path": "SearchParameter.name",
"short": "Name for this search parameter (computer friendly)",
"definition": "A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "SearchParameter.status",
"path": "SearchParameter.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this search parameter. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of search parameters that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired search parameter without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "SearchParameter.experimental",
"path": "SearchParameter.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of search parameter that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental search parameter in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level search parameter.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "SearchParameter.date",
"path": "SearchParameter.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the search parameter. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "SearchParameter.publisher",
"path": "SearchParameter.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the search parameter.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the search parameter is the organization or individual primarily responsible for the maintenance and upkeep of the search parameter. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the search parameter. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the search parameter. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "SearchParameter.contact",
"path": "SearchParameter.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "SearchParameter.useContext",
"path": "SearchParameter.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate search parameter instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "SearchParameter.jurisdiction",
"path": "SearchParameter.jurisdiction",
"short": "Intended jurisdiction for search parameter (if applicable)",
"definition": "A legal or geographic region in which the search parameter is intended to be used.",
"comment": "It may be possible for the search parameter to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "SearchParameter.purpose",
"path": "SearchParameter.purpose",
"short": "Why this search parameter is defined",
"definition": "Explaination of why this search parameter is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the search parameter Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this search parameter.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "SearchParameter.code",
"path": "SearchParameter.code",
"short": "Code used in URL",
"definition": "The code used in the URL or the parameter name in a parameters resource for this search parameter.",
"comment": "For maximum compatibility, use only lowercase ASCII characters.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true
},
{
"id": "SearchParameter.base",
"path": "SearchParameter.base",
"short": "The resource type(s) this search parameter applies to",
"definition": "The base resource type(s) that this search parameter can be used against.",
"comment": "A search parameter must always have at least one type. When search parameters have more than one resource, they can be used against any of the listed resource types, or in a cross-type search (see [Cross Resource Search](http.html#xres-search)).",
"min": 1,
"max": "*",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResourceType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "One of the resource types defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/resource-types"
}
}
},
{
"id": "SearchParameter.type",
"path": "SearchParameter.type",
"short": "number | date | string | token | reference | composite | quantity | uri",
"definition": "The type of value a search parameter refers to, and how the content is interpreted.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SearchParamType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Data types allowed to be used for search parameters.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/search-param-type"
}
}
},
{
"id": "SearchParameter.derivedFrom",
"path": "SearchParameter.derivedFrom",
"short": "Original Definition for the search parameter",
"definition": "Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.",
"comment": "The intent of this is that a server can designate that it provides support for a search parameter defined in the specification itself (e.g. [`value-quantity`](http://hl7.org/fhir/SearchParameter/Observation-value-quantity), but detail how it is supported by the server.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "SearchParameter.description",
"path": "SearchParameter.description",
"short": "Natural language description of the search parameter",
"definition": "A free text natural language description of the search parameter from a consumer's perspective. and how it used.",
"comment": "This description can be used to capture details such as why the search parameter was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the search parameter as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 1,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"isSummary": true
},
{
"id": "SearchParameter.expression",
"path": "SearchParameter.expression",
"short": "FHIRPath expression that extracts the values",
"definition": "A FHIRPath expression that returns a set of elements for the search parameter.",
"comment": "Note that the elements returned by the expression are sometimes complex elements where logic is required to determine quite how to handle them; e.g. CodeableConcepts may contain text and/or multiple codings, where the codings themselves contain a code and a system. For composite search parameters, the outcome of the expression must a collection of base elements from which the composites are derived.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"spd-1"
]
},
{
"id": "SearchParameter.xpath",
"path": "SearchParameter.xpath",
"short": "XPath that extracts the values",
"definition": "An XPath expression that returns a set of elements for the search parameter.",
"comment": "Note that the elements returned by the XPath are sometimes complex elements where logic is required to determine quite how to handle them; e.g. CodeableConcepts may contain text and/or multiple codings, where the codings themselves contain a code and a system.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"spd-1"
]
},
{
"id": "SearchParameter.xpathUsage",
"path": "SearchParameter.xpathUsage",
"short": "normal | phonetic | nearby | distance | other",
"definition": "How the search parameter relates to the set of elements returned by evaluating the xpath query.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"spd-1"
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "XPathUsageType"
}
],
"strength": "required",
"description": "How a search parameter relates to the set of elements returned by evaluating its xpath query.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/search-xpath-usage"
}
}
},
{
"id": "SearchParameter.target",
"path": "SearchParameter.target",
"short": "Types of resource (if a resource reference)",
"definition": "Types of resource (if a resource is referenced).",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ResourceType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "One of the resource types defined as part of FHIR.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/resource-types"
}
}
},
{
"id": "SearchParameter.comparator",
"path": "SearchParameter.comparator",
"short": "eq | ne | gt | lt | ge | le | sa | eb | ap",
"definition": "Comparators supported for the search parameter.",
"comment": "If no comparators are listed, clients should not expect servers to support any comparators.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SearchComparator"
}
],
"strength": "required",
"description": "What Search Comparator Codes are supported in search",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/search-comparator"
}
}
},
{
"id": "SearchParameter.modifier",
"path": "SearchParameter.modifier",
"short": "missing | exact | contains | not | text | in | not-in | below | above | type",
"definition": "A modifier supported for the search parameter.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SearchModifierCode"
}
],
"strength": "required",
"description": "A supported modifier for a search parameter.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/search-modifier-code"
}
}
},
{
"id": "SearchParameter.chain",
"path": "SearchParameter.chain",
"short": "Chained names supported",
"definition": "Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.",
"comment": "Systems are not required to list all the chain names they support, but if they don't list them, clients may not know to use them.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
]
},
{
"id": "SearchParameter.component",
"path": "SearchParameter.component",
"short": "For Composite resources to define the parts",
"definition": "Used to define the parts of a composite search parameter.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "SearchParameter.component.definition",
"path": "SearchParameter.component.definition",
"short": "Defines how the part works",
"definition": "The definition of the search parameter that describes this part.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/SearchParameter"
}
]
},
{
"id": "SearchParameter.component.expression",
"path": "SearchParameter.component.expression",
"short": "Subexpression relative to main expression",
"definition": "A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.",
"comment": "This expression overrides the expression in the definition, and extracts the index values from the outcome of the composite expression.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Sequence",
"resource": {
"resourceType": "StructureDefinition",
"id": "Sequence",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Sequence ΣI DomainResource Information about a biological sequence
+ Only 0 and 1 are valid for coordinateSystem
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier Unique ID for this particular sequence. This is a FHIR-defined id
type Σ 0..1 code aa | dna | rna
sequenceType (Example) coordinateSystem Σ 1..1 integer Base number of coordinate system (0 for 0-based numbering or coordinates, inclusive start, exclusive end, 1 for 1-based numbering, inclusive start, inclusive end) patient Σ 0..1 Reference(Patient) Who and/or what this is about specimen Σ 0..1 Reference(Specimen) Specimen used for sequencing device Σ 0..1 Reference(Device) The method for sequencing performer Σ 0..1 Reference(Organization) Who should be responsible for test result quantity Σ 0..1 Quantity The number of copies of the seqeunce of interest. (RNASeq) referenceSeq ΣI 0..1 BackboneElement A sequence used as reference
+ Only +1 and -1 are valid for strand
+ GenomeBuild and chromosome must be both contained if either one of them is contained
+ Have and only have one of the following elements in referenceSeq : 1. genomeBuild ; 2 referenceSeqId; 3. referenceSeqPointer; 4. referenceSeqString; chromosome Σ 0..1 CodeableConcept Chromosome containing genetic finding
chromosome-human (Example) genomeBuild Σ 0..1 string The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37' referenceSeqId Σ 0..1 CodeableConcept Reference identifier
ENSEMBL (Example) referenceSeqPointer Σ 0..1 Reference(Sequence) A Pointer to another Sequence entity as reference sequence referenceSeqString Σ 0..1 string A string to represent reference sequence strand Σ 0..1 integer Directionality of DNA ( +1/-1) windowStart Σ 1..1 integer Start position of the window on the reference sequence windowEnd Σ 1..1 integer End position of the window on the reference sequence variant Σ 0..* BackboneElement Variant in sequence
start Σ 0..1 integer Start position of the variant on the reference sequence end Σ 0..1 integer End position of the variant on the reference sequence observedAllele Σ 0..1 string Allele that was observed referenceAllele Σ 0..1 string Allele in the reference sequence cigar Σ 0..1 string Extended CIGAR string for aligning the sequence with reference bases variantPointer Σ 0..1 Reference(Observation) Pointer to observed variant information observedSeq Σ 0..1 string Sequence that was observed quality Σ 0..* BackboneElement An set of value as quality of sequence
type Σ 1..1 code indel | snp | unknown
qualityType (Required) standardSequence Σ 0..1 CodeableConcept Standard sequence for comparison
FDA-StandardSequence (Example) start Σ 0..1 integer Start position of the sequence end Σ 0..1 integer End position of the sequence score Σ 0..1 Quantity Quality score for the comparison method Σ 0..1 CodeableConcept Method to get quality
FDA-Method (Example) truthTP Σ 0..1 decimal True positives from the perspective of the truth data queryTP Σ 0..1 decimal True positives from the perspective of the query data truthFN Σ 0..1 decimal False negatives queryFP Σ 0..1 decimal False positives gtFP Σ 0..1 decimal False positives where the non-REF alleles in the Truth and Query Call Sets match precision Σ 0..1 decimal Precision of comparison recall Σ 0..1 decimal Recall of comparison fScore Σ 0..1 decimal F-score readCoverage Σ 0..1 integer Average number of reads representing a given nucleotide in the reconstructed sequence repository Σ 0..* BackboneElement External repository which contains detailed report related with observedSeq in this resource
type Σ 1..1 code directlink | openapi | login | oauth | other
repositoryType (Required) url Σ 0..1 uri URI of the repository name Σ 0..1 string Repository's name datasetId Σ 0..1 string Id of the dataset that used to call for dataset in repository variantsetId Σ 0..1 string Id of the variantset that used to call for variantset in repository readsetId Σ 0..1 string Id of the read pointer Σ 0..* Reference(Sequence) Pointer to next atomic sequence
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 1
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "cg"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Sequence",
"name": "Sequence",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Clinical Genomics)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/clingenomics/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Sequence Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Sequence",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Sequence",
"path": "Sequence",
"short": "Information about a biological sequence",
"definition": "Raw data describing a biological sequence.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "seq-3",
"severity": "error",
"human": "Only 0 and 1 are valid for coordinateSystem",
"expression": "coordinateSystem = 1 or coordinateSystem = 0",
"xpath": "count(f:coordinateSystem[@value=0 and @value=1]) = 1"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "w5",
"map": "clinical.diagnostics"
}
]
},
{
"id": "Sequence.id",
"path": "Sequence.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Sequence.meta",
"path": "Sequence.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Sequence.implicitRules",
"path": "Sequence.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Sequence.language",
"path": "Sequence.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Sequence.text",
"path": "Sequence.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Sequence.contained",
"path": "Sequence.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Sequence.extension",
"path": "Sequence.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Sequence.modifierExtension",
"path": "Sequence.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Sequence.identifier",
"path": "Sequence.identifier",
"short": "Unique ID for this particular sequence. This is a FHIR-defined id",
"definition": "A unique identifier for this particular sequence instance. This is a FHIR-defined id.",
"requirements": "Allows sequences to be distinguished and referenced.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Sequence.type",
"path": "Sequence.type",
"short": "aa | dna | rna",
"definition": "Amino Acid Sequence/ DNA Sequence / RNA Sequence.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "sequenceType"
}
],
"strength": "example",
"description": "Type if a sequence -- DNA, RNA, or amino acid sequence",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/sequence-type"
}
}
},
{
"id": "Sequence.coordinateSystem",
"path": "Sequence.coordinateSystem",
"short": "Base number of coordinate system (0 for 0-based numbering or coordinates, inclusive start, exclusive end, 1 for 1-based numbering, inclusive start, inclusive end)",
"definition": "Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.patient",
"path": "Sequence.patient",
"short": "Who and/or what this is about",
"definition": "The patient whose sequencing results are described by this resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"isSummary": true
},
{
"id": "Sequence.specimen",
"path": "Sequence.specimen",
"short": "Specimen used for sequencing",
"definition": "Specimen used for sequencing.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Specimen"
}
],
"isSummary": true
},
{
"id": "Sequence.device",
"path": "Sequence.device",
"short": "The method for sequencing",
"definition": "The method for sequencing, for example, chip information.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true
},
{
"id": "Sequence.performer",
"path": "Sequence.performer",
"short": "Who should be responsible for test result",
"definition": "The organization or lab that should be responsible for this result.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true
},
{
"id": "Sequence.quantity",
"path": "Sequence.quantity",
"short": "The number of copies of the seqeunce of interest. (RNASeq)",
"definition": "The number of copies of the seqeunce of interest. (RNASeq).",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq",
"path": "Sequence.referenceSeq",
"short": "A sequence used as reference",
"definition": "A sequence that is used as a reference to describe variants that are present in a sequence analyzed.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "seq-4",
"severity": "error",
"human": "Only +1 and -1 are valid for strand",
"expression": "strand.empty() or strand = 1 or strand = -1",
"xpath": "not(exists(f:strand)) or count(f:strand[@value=-1 and @value=1]) = 1"
},
{
"key": "seq-5",
"severity": "error",
"human": "GenomeBuild and chromosome must be both contained if either one of them is contained",
"expression": "(chromosome.empty() and genomeBuild.empty()) or (chromosome.exists() and genomeBuild.exists())",
"xpath": "(exists(f:chromosome) and exists(f:genomeBuild)) or (not(exists(f:chromosome)) and not(exists(f:genomeBuild)))"
},
{
"key": "seq-6",
"severity": "error",
"human": "Have and only have one of the following elements in referenceSeq : 1. genomeBuild ; 2 referenceSeqId; 3. referenceSeqPointer; 4. referenceSeqString;",
"expression": "(genomeBuild.count()+referenceSeqId.count()+ referenceSeqPointer.count()+ referenceSeqString.count()) = 1",
"xpath": "count(f:genomeBuild)+count(f:referenceSeqId)+count(f:referenceSeqPointer)+count(f:referenceSeqString)=1"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.id",
"path": "Sequence.referenceSeq.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Sequence.referenceSeq.extension",
"path": "Sequence.referenceSeq.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Sequence.referenceSeq.modifierExtension",
"path": "Sequence.referenceSeq.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Sequence.referenceSeq.chromosome",
"path": "Sequence.referenceSeq.chromosome",
"short": "Chromosome containing genetic finding",
"definition": "Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "chromosome-human"
}
],
"strength": "example",
"description": "Chromosome number for human",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/chromosome-human"
}
}
},
{
"id": "Sequence.referenceSeq.genomeBuild",
"path": "Sequence.referenceSeq.genomeBuild",
"short": "The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'",
"definition": "The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'. Version number must be included if a versioned release of a primary build was used.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.referenceSeqId",
"path": "Sequence.referenceSeq.referenceSeqId",
"short": "Reference identifier",
"definition": "Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "sequenceReference"
}
],
"strength": "example",
"description": "Reference identifier",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/sequence-referenceSeq"
}
}
},
{
"id": "Sequence.referenceSeq.referenceSeqPointer",
"path": "Sequence.referenceSeq.referenceSeqPointer",
"short": "A Pointer to another Sequence entity as reference sequence",
"definition": "A Pointer to another Sequence entity as reference sequence.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Sequence"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.referenceSeqString",
"path": "Sequence.referenceSeq.referenceSeqString",
"short": "A string to represent reference sequence",
"definition": "A string like \"ACGT\".",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.strand",
"path": "Sequence.referenceSeq.strand",
"short": "Directionality of DNA ( +1/-1)",
"definition": "Directionality of DNA sequence. Available values are \"1\" for the plus strand (5' to 3')/Watson/Sense/positive and \"-1\" for the minus strand(3' to 5')/Crick/Antisense/negative.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.windowStart",
"path": "Sequence.referenceSeq.windowStart",
"short": "Start position of the window on the reference sequence",
"definition": "Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.windowEnd",
"path": "Sequence.referenceSeq.windowEnd",
"short": "End position of the window on the reference sequence",
"definition": "End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.variant",
"path": "Sequence.variant",
"short": "Variant in sequence",
"definition": "The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.) It can represent some complex mutation or segment variation with the assist of CIGAR string.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.id",
"path": "Sequence.variant.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Sequence.variant.extension",
"path": "Sequence.variant.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Sequence.variant.modifierExtension",
"path": "Sequence.variant.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Sequence.variant.start",
"path": "Sequence.variant.start",
"short": "Start position of the variant on the reference sequence",
"definition": "Start position of the variant on the reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.end",
"path": "Sequence.variant.end",
"short": "End position of the variant on the reference sequence",
"definition": "End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.observedAllele",
"path": "Sequence.variant.observedAllele",
"short": "Allele that was observed",
"definition": "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.referenceAllele",
"path": "Sequence.variant.referenceAllele",
"short": "Allele in the reference sequence",
"definition": "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.cigar",
"path": "Sequence.variant.cigar",
"short": "Extended CIGAR string for aligning the sequence with reference bases",
"definition": "Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.variantPointer",
"path": "Sequence.variant.variantPointer",
"short": "Pointer to observed variant information",
"definition": "A pointer to an Observation containing variant information.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"isSummary": true
},
{
"id": "Sequence.observedSeq",
"path": "Sequence.observedSeq",
"short": "Sequence that was observed",
"definition": "Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.quality",
"path": "Sequence.quality",
"short": "An set of value as quality of sequence",
"definition": "An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686)).",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.id",
"path": "Sequence.quality.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Sequence.quality.extension",
"path": "Sequence.quality.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Sequence.quality.modifierExtension",
"path": "Sequence.quality.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Sequence.quality.type",
"path": "Sequence.quality.type",
"short": "indel | snp | unknown",
"definition": "INDEL / SNP / Undefined variant.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "qualityType"
}
],
"strength": "required",
"description": "Type for quality report",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/quality-type"
}
}
},
{
"id": "Sequence.quality.standardSequence",
"path": "Sequence.quality.standardSequence",
"short": "Standard sequence for comparison",
"definition": "Gold standard sequence used for comparing against.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "qualityStandardSequence"
}
],
"strength": "example",
"description": "Reference identifier of the sequence that used to mark the quality of tested samples.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/sequence-quality-standardSequence"
}
}
},
{
"id": "Sequence.quality.start",
"path": "Sequence.quality.start",
"short": "Start position of the sequence",
"definition": "Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.end",
"path": "Sequence.quality.end",
"short": "End position of the sequence",
"definition": "End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.score",
"path": "Sequence.quality.score",
"short": "Quality score for the comparison",
"definition": "The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)).",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.method",
"path": "Sequence.quality.method",
"short": "Method to get quality",
"definition": "Which method is used to get sequence quality.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "qualityMethod"
}
],
"strength": "example",
"description": "The method used to evaluate the numerical quality of the observed sequence.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/sequence-quality-method"
}
}
},
{
"id": "Sequence.quality.truthTP",
"path": "Sequence.quality.truthTP",
"short": "True positives from the perspective of the truth data",
"definition": "True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.queryTP",
"path": "Sequence.quality.queryTP",
"short": "True positives from the perspective of the query data",
"definition": "True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.truthFN",
"path": "Sequence.quality.truthFN",
"short": "False negatives",
"definition": "False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.queryFP",
"path": "Sequence.quality.queryFP",
"short": "False positives",
"definition": "False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.gtFP",
"path": "Sequence.quality.gtFP",
"short": "False positives where the non-REF alleles in the Truth and Query Call Sets match",
"definition": "The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.precision",
"path": "Sequence.quality.precision",
"short": "Precision of comparison",
"definition": "QUERY.TP / (QUERY.TP + QUERY.FP).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.recall",
"path": "Sequence.quality.recall",
"short": "Recall of comparison",
"definition": "TRUTH.TP / (TRUTH.TP + TRUTH.FN).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.fScore",
"path": "Sequence.quality.fScore",
"short": "F-score",
"definition": "Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.readCoverage",
"path": "Sequence.readCoverage",
"short": "Average number of reads representing a given nucleotide in the reconstructed sequence",
"definition": "Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.repository",
"path": "Sequence.repository",
"short": "External repository which contains detailed report related with observedSeq in this resource",
"definition": "Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true
},
{
"id": "Sequence.repository.id",
"path": "Sequence.repository.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Sequence.repository.extension",
"path": "Sequence.repository.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Sequence.repository.modifierExtension",
"path": "Sequence.repository.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Sequence.repository.type",
"path": "Sequence.repository.type",
"short": "directlink | openapi | login | oauth | other",
"definition": "Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "repositoryType"
}
],
"strength": "required",
"description": "Type for access of external URI",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/repository-type"
}
}
},
{
"id": "Sequence.repository.url",
"path": "Sequence.repository.url",
"short": "URI of the repository",
"definition": "URI of an external repository which contains further details about the genetics data.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true
},
{
"id": "Sequence.repository.name",
"path": "Sequence.repository.name",
"short": "Repository's name",
"definition": "URI of an external repository which contains further details about the genetics data.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.repository.datasetId",
"path": "Sequence.repository.datasetId",
"short": "Id of the dataset that used to call for dataset in repository",
"definition": "Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.repository.variantsetId",
"path": "Sequence.repository.variantsetId",
"short": "Id of the variantset that used to call for variantset in repository",
"definition": "Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.repository.readsetId",
"path": "Sequence.repository.readsetId",
"short": "Id of the read",
"definition": "Id of the read in this external repository.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.pointer",
"path": "Sequence.pointer",
"short": "Pointer to next atomic sequence",
"definition": "Pointer to next atomic sequence which at most contains one variant.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Sequence"
}
],
"isSummary": true
}
]
},
"differential": {
"element": [
{
"id": "Sequence",
"path": "Sequence",
"short": "Information about a biological sequence",
"definition": "Raw data describing a biological sequence.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "seq-3",
"severity": "error",
"human": "Only 0 and 1 are valid for coordinateSystem",
"expression": "coordinateSystem = 1 or coordinateSystem = 0",
"xpath": "count(f:coordinateSystem[@value=0 and @value=1]) = 1"
}
],
"mapping": [
{
"identity": "w5",
"map": "clinical.diagnostics"
}
]
},
{
"id": "Sequence.identifier",
"path": "Sequence.identifier",
"short": "Unique ID for this particular sequence. This is a FHIR-defined id",
"definition": "A unique identifier for this particular sequence instance. This is a FHIR-defined id.",
"requirements": "Allows sequences to be distinguished and referenced.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Sequence.type",
"path": "Sequence.type",
"short": "aa | dna | rna",
"definition": "Amino Acid Sequence/ DNA Sequence / RNA Sequence.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "sequenceType"
}
],
"strength": "example",
"description": "Type if a sequence -- DNA, RNA, or amino acid sequence",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/sequence-type"
}
}
},
{
"id": "Sequence.coordinateSystem",
"path": "Sequence.coordinateSystem",
"short": "Base number of coordinate system (0 for 0-based numbering or coordinates, inclusive start, exclusive end, 1 for 1-based numbering, inclusive start, inclusive end)",
"definition": "Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.patient",
"path": "Sequence.patient",
"short": "Who and/or what this is about",
"definition": "The patient whose sequencing results are described by this resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"isSummary": true
},
{
"id": "Sequence.specimen",
"path": "Sequence.specimen",
"short": "Specimen used for sequencing",
"definition": "Specimen used for sequencing.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Specimen"
}
],
"isSummary": true
},
{
"id": "Sequence.device",
"path": "Sequence.device",
"short": "The method for sequencing",
"definition": "The method for sequencing, for example, chip information.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true
},
{
"id": "Sequence.performer",
"path": "Sequence.performer",
"short": "Who should be responsible for test result",
"definition": "The organization or lab that should be responsible for this result.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true
},
{
"id": "Sequence.quantity",
"path": "Sequence.quantity",
"short": "The number of copies of the seqeunce of interest. (RNASeq)",
"definition": "The number of copies of the seqeunce of interest. (RNASeq).",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq",
"path": "Sequence.referenceSeq",
"short": "A sequence used as reference",
"definition": "A sequence that is used as a reference to describe variants that are present in a sequence analyzed.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "seq-4",
"severity": "error",
"human": "Only +1 and -1 are valid for strand",
"expression": "strand.empty() or strand = 1 or strand = -1",
"xpath": "not(exists(f:strand)) or count(f:strand[@value=-1 and @value=1]) = 1"
},
{
"key": "seq-5",
"severity": "error",
"human": "GenomeBuild and chromosome must be both contained if either one of them is contained",
"expression": "(chromosome.empty() and genomeBuild.empty()) or (chromosome.exists() and genomeBuild.exists())",
"xpath": "(exists(f:chromosome) and exists(f:genomeBuild)) or (not(exists(f:chromosome)) and not(exists(f:genomeBuild)))"
},
{
"key": "seq-6",
"severity": "error",
"human": "Have and only have one of the following elements in referenceSeq : 1. genomeBuild ; 2 referenceSeqId; 3. referenceSeqPointer; 4. referenceSeqString;",
"expression": "(genomeBuild.count()+referenceSeqId.count()+ referenceSeqPointer.count()+ referenceSeqString.count()) = 1",
"xpath": "count(f:genomeBuild)+count(f:referenceSeqId)+count(f:referenceSeqPointer)+count(f:referenceSeqString)=1"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.chromosome",
"path": "Sequence.referenceSeq.chromosome",
"short": "Chromosome containing genetic finding",
"definition": "Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "chromosome-human"
}
],
"strength": "example",
"description": "Chromosome number for human",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/chromosome-human"
}
}
},
{
"id": "Sequence.referenceSeq.genomeBuild",
"path": "Sequence.referenceSeq.genomeBuild",
"short": "The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'",
"definition": "The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'. Version number must be included if a versioned release of a primary build was used.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.referenceSeqId",
"path": "Sequence.referenceSeq.referenceSeqId",
"short": "Reference identifier",
"definition": "Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "sequenceReference"
}
],
"strength": "example",
"description": "Reference identifier",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/sequence-referenceSeq"
}
}
},
{
"id": "Sequence.referenceSeq.referenceSeqPointer",
"path": "Sequence.referenceSeq.referenceSeqPointer",
"short": "A Pointer to another Sequence entity as reference sequence",
"definition": "A Pointer to another Sequence entity as reference sequence.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Sequence"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.referenceSeqString",
"path": "Sequence.referenceSeq.referenceSeqString",
"short": "A string to represent reference sequence",
"definition": "A string like \"ACGT\".",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.strand",
"path": "Sequence.referenceSeq.strand",
"short": "Directionality of DNA ( +1/-1)",
"definition": "Directionality of DNA sequence. Available values are \"1\" for the plus strand (5' to 3')/Watson/Sense/positive and \"-1\" for the minus strand(3' to 5')/Crick/Antisense/negative.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.windowStart",
"path": "Sequence.referenceSeq.windowStart",
"short": "Start position of the window on the reference sequence",
"definition": "Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.referenceSeq.windowEnd",
"path": "Sequence.referenceSeq.windowEnd",
"short": "End position of the window on the reference sequence",
"definition": "End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.variant",
"path": "Sequence.variant",
"short": "Variant in sequence",
"definition": "The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.) It can represent some complex mutation or segment variation with the assist of CIGAR string.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.start",
"path": "Sequence.variant.start",
"short": "Start position of the variant on the reference sequence",
"definition": "Start position of the variant on the reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.end",
"path": "Sequence.variant.end",
"short": "End position of the variant on the reference sequence",
"definition": "End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.observedAllele",
"path": "Sequence.variant.observedAllele",
"short": "Allele that was observed",
"definition": "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.referenceAllele",
"path": "Sequence.variant.referenceAllele",
"short": "Allele in the reference sequence",
"definition": "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.cigar",
"path": "Sequence.variant.cigar",
"short": "Extended CIGAR string for aligning the sequence with reference bases",
"definition": "Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.variant.variantPointer",
"path": "Sequence.variant.variantPointer",
"short": "Pointer to observed variant information",
"definition": "A pointer to an Observation containing variant information.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Observation"
}
],
"isSummary": true
},
{
"id": "Sequence.observedSeq",
"path": "Sequence.observedSeq",
"short": "Sequence that was observed",
"definition": "Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.quality",
"path": "Sequence.quality",
"short": "An set of value as quality of sequence",
"definition": "An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686)).",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.type",
"path": "Sequence.quality.type",
"short": "indel | snp | unknown",
"definition": "INDEL / SNP / Undefined variant.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "qualityType"
}
],
"strength": "required",
"description": "Type for quality report",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/quality-type"
}
}
},
{
"id": "Sequence.quality.standardSequence",
"path": "Sequence.quality.standardSequence",
"short": "Standard sequence for comparison",
"definition": "Gold standard sequence used for comparing against.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "qualityStandardSequence"
}
],
"strength": "example",
"description": "Reference identifier of the sequence that used to mark the quality of tested samples.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/sequence-quality-standardSequence"
}
}
},
{
"id": "Sequence.quality.start",
"path": "Sequence.quality.start",
"short": "Start position of the sequence",
"definition": "Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.end",
"path": "Sequence.quality.end",
"short": "End position of the sequence",
"definition": "End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.score",
"path": "Sequence.quality.score",
"short": "Quality score for the comparison",
"definition": "The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)).",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.method",
"path": "Sequence.quality.method",
"short": "Method to get quality",
"definition": "Which method is used to get sequence quality.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "qualityMethod"
}
],
"strength": "example",
"description": "The method used to evaluate the numerical quality of the observed sequence.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/sequence-quality-method"
}
}
},
{
"id": "Sequence.quality.truthTP",
"path": "Sequence.quality.truthTP",
"short": "True positives from the perspective of the truth data",
"definition": "True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.queryTP",
"path": "Sequence.quality.queryTP",
"short": "True positives from the perspective of the query data",
"definition": "True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.truthFN",
"path": "Sequence.quality.truthFN",
"short": "False negatives",
"definition": "False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.queryFP",
"path": "Sequence.quality.queryFP",
"short": "False positives",
"definition": "False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.gtFP",
"path": "Sequence.quality.gtFP",
"short": "False positives where the non-REF alleles in the Truth and Query Call Sets match",
"definition": "The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.precision",
"path": "Sequence.quality.precision",
"short": "Precision of comparison",
"definition": "QUERY.TP / (QUERY.TP + QUERY.FP).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.recall",
"path": "Sequence.quality.recall",
"short": "Recall of comparison",
"definition": "TRUTH.TP / (TRUTH.TP + TRUTH.FN).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.quality.fScore",
"path": "Sequence.quality.fScore",
"short": "F-score",
"definition": "Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "Sequence.readCoverage",
"path": "Sequence.readCoverage",
"short": "Average number of reads representing a given nucleotide in the reconstructed sequence",
"definition": "Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "Sequence.repository",
"path": "Sequence.repository",
"short": "External repository which contains detailed report related with observedSeq in this resource",
"definition": "Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true
},
{
"id": "Sequence.repository.type",
"path": "Sequence.repository.type",
"short": "directlink | openapi | login | oauth | other",
"definition": "Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "repositoryType"
}
],
"strength": "required",
"description": "Type for access of external URI",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/repository-type"
}
}
},
{
"id": "Sequence.repository.url",
"path": "Sequence.repository.url",
"short": "URI of the repository",
"definition": "URI of an external repository which contains further details about the genetics data.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true
},
{
"id": "Sequence.repository.name",
"path": "Sequence.repository.name",
"short": "Repository's name",
"definition": "URI of an external repository which contains further details about the genetics data.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.repository.datasetId",
"path": "Sequence.repository.datasetId",
"short": "Id of the dataset that used to call for dataset in repository",
"definition": "Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.repository.variantsetId",
"path": "Sequence.repository.variantsetId",
"short": "Id of the variantset that used to call for variantset in repository",
"definition": "Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.repository.readsetId",
"path": "Sequence.repository.readsetId",
"short": "Id of the read",
"definition": "Id of the read in this external repository.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Sequence.pointer",
"path": "Sequence.pointer",
"short": "Pointer to next atomic sequence",
"definition": "Pointer to next atomic sequence which at most contains one variant.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Sequence"
}
],
"isSummary": true
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/ServiceDefinition",
"resource": {
"resourceType": "StructureDefinition",
"id": "ServiceDefinition",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints ServiceDefinition DomainResource A description of decision support service functionality
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension url Σ 0..1 uri Logical URI to reference this service definition (globally unique) identifier Σ 0..* Identifier Additional identifier for the service definition
version Σ 0..1 string Business version of the service definition name Σ 0..1 string Name for this service definition (computer friendly) title Σ 0..1 string Name for this service definition (human friendly) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) experimental ?!Σ 0..1 boolean For testing purposes, not real usage date Σ 0..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) description 0..1 markdown Natural language description of the service definition purpose 0..1 markdown Why this service definition is defined usage 0..1 string Describes the clinical usage of the module approvalDate 0..1 date When the service definition was approved by publisher lastReviewDate 0..1 date When the service definition was last reviewed effectivePeriod Σ 0..1 Period When the service definition is expected to be used useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for service definition (if applicable)
Jurisdiction ValueSet (Extensible)
topic 0..* CodeableConcept E.g. Education, Treatment, Assessment, etc
DefinitionTopic (Example)
contributor 0..* Contributor A content contributor
contact Σ 0..* ContactDetail Contact details for the publisher
copyright 0..1 markdown Use and/or publishing restrictions relatedArtifact 0..* RelatedArtifact Additional documentation, citations, etc
trigger 0..* TriggerDefinition "when" the module should be invoked
dataRequirement 0..* DataRequirement What data is used by the module
operationDefinition 0..1 Reference(OperationDefinition) Operation to invoke
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 0
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "cds"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/ServiceDefinition",
"name": "ServiceDefinition",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Clinical Decision Support)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/dss/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for ServiceDefinition Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "objimpl",
"uri": "http://hl7.org/fhir/object-implementation",
"name": "Object Implementation Information"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "ServiceDefinition",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"_baseDefinition": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-codegen-super",
"valueString": "MetadataResource"
}
]
},
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "ServiceDefinition",
"path": "ServiceDefinition",
"short": "A description of decision support service functionality",
"definition": "The ServiceDefinition describes a unit of decision support functionality that is made available as a service, such as immunization modules or drug-drug interaction checking.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Definition"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "ServiceDefinition.id",
"path": "ServiceDefinition.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "ServiceDefinition.meta",
"path": "ServiceDefinition.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "ServiceDefinition.implicitRules",
"path": "ServiceDefinition.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "ServiceDefinition.language",
"path": "ServiceDefinition.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "ServiceDefinition.text",
"path": "ServiceDefinition.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "ServiceDefinition.contained",
"path": "ServiceDefinition.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ServiceDefinition.extension",
"path": "ServiceDefinition.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ServiceDefinition.modifierExtension",
"path": "ServiceDefinition.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ServiceDefinition.url",
"path": "ServiceDefinition.url",
"short": "Logical URI to reference this service definition (globally unique)",
"definition": "An absolute URI that is used to identify this service definition when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this service definition is (or will be) published. The URL SHOULD include the major version of the service definition. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the service definition to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.url"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ServiceDefinition.identifier",
"path": "ServiceDefinition.identifier",
"short": "Additional identifier for the service definition",
"definition": "A formal identifier that is used to identify this service definition when it is represented in other formats, or referenced in a specification, model, design or an instance. This is used for CMS or NQF identifiers for a measure artifact. Note that at least one identifier is required for non-experimental active artifacts.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this service definition outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.identifier"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ServiceDefinition.version",
"path": "ServiceDefinition.version",
"short": "Business version of the service definition",
"definition": "The identifier that is used to identify this version of the service definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the service definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different service definition instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the service definition with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.version"
},
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "ServiceDefinition.name",
"path": "ServiceDefinition.name",
"short": "Name for this service definition (computer friendly)",
"definition": "A natural language name identifying the service definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "ServiceDefinition.title",
"path": "ServiceDefinition.title",
"short": "Name for this service definition (human friendly)",
"definition": "A short, descriptive, user-friendly title for the service definition.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.title"
}
]
},
{
"id": "ServiceDefinition.status",
"path": "ServiceDefinition.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this service definition. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of service definitions that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired service definition without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ServiceDefinition.experimental",
"path": "ServiceDefinition.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this service definition is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of service definition that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental service definition in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level service definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.experimental"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ServiceDefinition.date",
"path": "ServiceDefinition.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the service definition was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the service definition changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the service definition. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.date"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ServiceDefinition.publisher",
"path": "ServiceDefinition.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the service definition.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the service definition is the organization or individual primarily responsible for the maintenance and upkeep of the service definition. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the service definition. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the service definition. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.publisher"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "ServiceDefinition.description",
"path": "ServiceDefinition.description",
"short": "Natural language description of the service definition",
"definition": "A free text natural language description of the service definition from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the service definition was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the service definition as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.description"
}
]
},
{
"id": "ServiceDefinition.purpose",
"path": "ServiceDefinition.purpose",
"short": "Why this service definition is defined",
"definition": "Explaination of why this service definition is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the service definition Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this service definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.purpose"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ServiceDefinition.usage",
"path": "ServiceDefinition.usage",
"short": "Describes the clinical usage of the module",
"definition": "A detailed description of how the module is used from a clinical perspective.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ServiceDefinition.approvalDate",
"path": "ServiceDefinition.approvalDate",
"short": "When the service definition was approved by publisher",
"definition": "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.",
"comment": "The 'date' element may be more recent than the approval date because of minor changes / editorial corrections.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.approvalDate"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "ServiceDefinition.lastReviewDate",
"path": "ServiceDefinition.lastReviewDate",
"short": "When the service definition was last reviewed",
"definition": "The date on which the resource content was last reviewed. Review happens periodically after approval, but doesn't change the original approval date.",
"comment": "If specified, this is usually after the approval date.",
"requirements": "Gives a sense of how \"current\" the content is. Resources that have not been reviewed in a long time may have a risk of being less appropriate/relevant.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.lastReviewDate"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "ServiceDefinition.effectivePeriod",
"path": "ServiceDefinition.effectivePeriod",
"short": "When the service definition is expected to be used",
"definition": "The period during which the service definition content was or is planned to be in active use.",
"comment": "The effective period for a service definition determines when the content is applicable for usage and is independent of publication and review dates. For example, a measure intended to be used for the year 2016 might be published in 2015.",
"requirements": "Allows establishing a transition before a resource comes into effect and also allows for a sunsetting process when new versions of a the service definition are or are expected to be used instead.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.effectivePeriod"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "ServiceDefinition.useContext",
"path": "ServiceDefinition.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate service definition instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.useContext"
}
]
},
{
"id": "ServiceDefinition.jurisdiction",
"path": "ServiceDefinition.jurisdiction",
"short": "Intended jurisdiction for service definition (if applicable)",
"definition": "A legal or geographic region in which the service definition is intended to be used.",
"comment": "It may be possible for the service definition to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.jurisdiction"
}
]
},
{
"id": "ServiceDefinition.topic",
"path": "ServiceDefinition.topic",
"short": "E.g. Education, Treatment, Assessment, etc",
"definition": "Descriptive topics related to the module. Topics provide a high-level categorization of the module that can be useful for filtering and searching.",
"requirements": "Repositories must be able to determine how to categorize the module so that it can be found by topical searches.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "DefinitionTopic"
}
],
"strength": "example",
"description": "High-level categorization of the definition, used for searching, sorting, and filtering",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/definition-topic"
}
}
},
{
"id": "ServiceDefinition.contributor",
"path": "ServiceDefinition.contributor",
"short": "A content contributor",
"definition": "A contributor to the content of the module, including authors, editors, reviewers, and endorsers.",
"requirements": "Consumers of the content must be able to quickly determine who contributed to the content of the knowledge module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Contributor"
}
]
},
{
"id": "ServiceDefinition.contact",
"path": "ServiceDefinition.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.contact"
}
]
},
{
"id": "ServiceDefinition.copyright",
"path": "ServiceDefinition.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the service definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the service definition.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the service definition and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.copyright"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "ServiceDefinition.relatedArtifact",
"path": "ServiceDefinition.relatedArtifact",
"short": "Additional documentation, citations, etc",
"definition": "Related resources such as additional documentation, justification, or bibliographic references.",
"comment": "Each related resource is either an attachment, or a reference to another resource, but not both.",
"requirements": "Modules must be able to provide enough information for consumers of the content (and/or interventions or results produced by the content) to be able to determine and understand the justification for and evidence in support of the content.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
]
},
{
"id": "ServiceDefinition.trigger",
"path": "ServiceDefinition.trigger",
"short": "\"when\" the module should be invoked",
"definition": "The trigger element defines when the rule should be invoked. This information is used by consumers of the rule to determine how to integrate the rule into a specific workflow.",
"min": 0,
"max": "*",
"type": [
{
"code": "TriggerDefinition"
}
]
},
{
"id": "ServiceDefinition.dataRequirement",
"path": "ServiceDefinition.dataRequirement",
"short": "What data is used by the module",
"definition": "Data requirements are a machine processable description of the data required by the module in order to perform a successful evaluation.",
"min": 0,
"max": "*",
"type": [
{
"code": "DataRequirement"
}
]
},
{
"id": "ServiceDefinition.operationDefinition",
"path": "ServiceDefinition.operationDefinition",
"short": "Operation to invoke",
"definition": "A reference to the operation that is used to invoke this service.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/OperationDefinition"
}
]
}
]
},
"differential": {
"element": [
{
"id": "ServiceDefinition",
"path": "ServiceDefinition",
"short": "A description of decision support service functionality",
"definition": "The ServiceDefinition describes a unit of decision support functionality that is made available as a service, such as immunization modules or drug-drug interaction checking.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Definition"
},
{
"identity": "w5",
"map": "clinical.general"
}
]
},
{
"id": "ServiceDefinition.url",
"path": "ServiceDefinition.url",
"short": "Logical URI to reference this service definition (globally unique)",
"definition": "An absolute URI that is used to identify this service definition when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this service definition is (or will be) published. The URL SHOULD include the major version of the service definition. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the service definition to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.url"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ServiceDefinition.identifier",
"path": "ServiceDefinition.identifier",
"short": "Additional identifier for the service definition",
"definition": "A formal identifier that is used to identify this service definition when it is represented in other formats, or referenced in a specification, model, design or an instance. This is used for CMS or NQF identifiers for a measure artifact. Note that at least one identifier is required for non-experimental active artifacts.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this service definition outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.identifier"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ServiceDefinition.version",
"path": "ServiceDefinition.version",
"short": "Business version of the service definition",
"definition": "The identifier that is used to identify this version of the service definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the service definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different service definition instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the service definition with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.version"
},
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "ServiceDefinition.name",
"path": "ServiceDefinition.name",
"short": "Name for this service definition (computer friendly)",
"definition": "A natural language name identifying the service definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "ServiceDefinition.title",
"path": "ServiceDefinition.title",
"short": "Name for this service definition (human friendly)",
"definition": "A short, descriptive, user-friendly title for the service definition.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.title"
}
]
},
{
"id": "ServiceDefinition.status",
"path": "ServiceDefinition.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this service definition. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of service definitions that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired service definition without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ServiceDefinition.experimental",
"path": "ServiceDefinition.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this service definition is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of service definition that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental service definition in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level service definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.experimental"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ServiceDefinition.date",
"path": "ServiceDefinition.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the service definition was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the service definition changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the service definition. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.date"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ServiceDefinition.publisher",
"path": "ServiceDefinition.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the service definition.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the service definition is the organization or individual primarily responsible for the maintenance and upkeep of the service definition. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the service definition. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the service definition. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.publisher"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "ServiceDefinition.description",
"path": "ServiceDefinition.description",
"short": "Natural language description of the service definition",
"definition": "A free text natural language description of the service definition from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the service definition was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the service definition as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.description"
}
]
},
{
"id": "ServiceDefinition.purpose",
"path": "ServiceDefinition.purpose",
"short": "Why this service definition is defined",
"definition": "Explaination of why this service definition is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the service definition Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this service definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.purpose"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ServiceDefinition.usage",
"path": "ServiceDefinition.usage",
"short": "Describes the clinical usage of the module",
"definition": "A detailed description of how the module is used from a clinical perspective.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ServiceDefinition.approvalDate",
"path": "ServiceDefinition.approvalDate",
"short": "When the service definition was approved by publisher",
"definition": "The date on which the resource content was approved by the publisher. Approval happens once when the content is officially approved for usage.",
"comment": "The 'date' element may be more recent than the approval date because of minor changes / editorial corrections.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.approvalDate"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "ServiceDefinition.lastReviewDate",
"path": "ServiceDefinition.lastReviewDate",
"short": "When the service definition was last reviewed",
"definition": "The date on which the resource content was last reviewed. Review happens periodically after approval, but doesn't change the original approval date.",
"comment": "If specified, this is usually after the approval date.",
"requirements": "Gives a sense of how \"current\" the content is. Resources that have not been reviewed in a long time may have a risk of being less appropriate/relevant.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.lastReviewDate"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "ServiceDefinition.effectivePeriod",
"path": "ServiceDefinition.effectivePeriod",
"short": "When the service definition is expected to be used",
"definition": "The period during which the service definition content was or is planned to be in active use.",
"comment": "The effective period for a service definition determines when the content is applicable for usage and is independent of publication and review dates. For example, a measure intended to be used for the year 2016 might be published in 2015.",
"requirements": "Allows establishing a transition before a resource comes into effect and also allows for a sunsetting process when new versions of a the service definition are or are expected to be used instead.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.effectivePeriod"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "ServiceDefinition.useContext",
"path": "ServiceDefinition.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate service definition instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.useContext"
}
]
},
{
"id": "ServiceDefinition.jurisdiction",
"path": "ServiceDefinition.jurisdiction",
"short": "Intended jurisdiction for service definition (if applicable)",
"definition": "A legal or geographic region in which the service definition is intended to be used.",
"comment": "It may be possible for the service definition to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Definition.jurisdiction"
}
]
},
{
"id": "ServiceDefinition.topic",
"path": "ServiceDefinition.topic",
"short": "E.g. Education, Treatment, Assessment, etc",
"definition": "Descriptive topics related to the module. Topics provide a high-level categorization of the module that can be useful for filtering and searching.",
"requirements": "Repositories must be able to determine how to categorize the module so that it can be found by topical searches.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "DefinitionTopic"
}
],
"strength": "example",
"description": "High-level categorization of the definition, used for searching, sorting, and filtering",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/definition-topic"
}
}
},
{
"id": "ServiceDefinition.contributor",
"path": "ServiceDefinition.contributor",
"short": "A content contributor",
"definition": "A contributor to the content of the module, including authors, editors, reviewers, and endorsers.",
"requirements": "Consumers of the content must be able to quickly determine who contributed to the content of the knowledge module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Contributor"
}
]
},
{
"id": "ServiceDefinition.contact",
"path": "ServiceDefinition.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Definition.contact"
}
]
},
{
"id": "ServiceDefinition.copyright",
"path": "ServiceDefinition.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the service definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the service definition.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the service definition and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Definition.copyright"
},
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "ServiceDefinition.relatedArtifact",
"path": "ServiceDefinition.relatedArtifact",
"short": "Additional documentation, citations, etc",
"definition": "Related resources such as additional documentation, justification, or bibliographic references.",
"comment": "Each related resource is either an attachment, or a reference to another resource, but not both.",
"requirements": "Modules must be able to provide enough information for consumers of the content (and/or interventions or results produced by the content) to be able to determine and understand the justification for and evidence in support of the content.",
"min": 0,
"max": "*",
"type": [
{
"code": "RelatedArtifact"
}
]
},
{
"id": "ServiceDefinition.trigger",
"path": "ServiceDefinition.trigger",
"short": "\"when\" the module should be invoked",
"definition": "The trigger element defines when the rule should be invoked. This information is used by consumers of the rule to determine how to integrate the rule into a specific workflow.",
"min": 0,
"max": "*",
"type": [
{
"code": "TriggerDefinition"
}
]
},
{
"id": "ServiceDefinition.dataRequirement",
"path": "ServiceDefinition.dataRequirement",
"short": "What data is used by the module",
"definition": "Data requirements are a machine processable description of the data required by the module in order to perform a successful evaluation.",
"min": 0,
"max": "*",
"type": [
{
"code": "DataRequirement"
}
]
},
{
"id": "ServiceDefinition.operationDefinition",
"path": "ServiceDefinition.operationDefinition",
"short": "Operation to invoke",
"definition": "A reference to the operation that is used to invoke this service.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/OperationDefinition"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Slot",
"resource": {
"resourceType": "StructureDefinition",
"id": "Slot",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Slot DomainResource A slot of time on a schedule that may be available for booking appointments
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier External Ids for this item
serviceCategory Σ 0..1 CodeableConcept A broad categorisation of the service that is to be performed during this appointment
ServiceCategory (Example) serviceType Σ 0..* CodeableConcept The type of appointments that can be booked into this slot (ideally this would be an identifiable service - which is at a location, rather than the location itself). If provided then this overrides the value provided on the availability resource
ServiceType (Example)
specialty Σ 0..* CodeableConcept The specialty of a practitioner that would be required to perform the service requested in this appointment
Practice Setting Code Value Set (Preferred)
appointmentType Σ 0..1 CodeableConcept The style of appointment or patient that may be booked in the slot (not service type)
v2 Appointment reason codes (Preferred) schedule Σ 1..1 Reference(Schedule) The schedule resource that this slot defines an interval of status information status Σ 1..1 code busy | free | busy-unavailable | busy-tentative | entered-in-error
SlotStatus (Required) start Σ 1..1 instant Date/Time that the slot is to begin end Σ 1..1 instant Date/Time that the slot is to conclude overbooked 0..1 boolean This slot has already been overbooked, appointments are unlikely to be accepted for this time comment 0..1 string Comments on the slot to describe any extended information. Such as custom constraints on the slot
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "pa"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Slot",
"name": "Slot",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Patient Administration)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/pafm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Slot Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "ical",
"uri": "http://www.ietf.org/rfc/rfc2445.txt",
"name": "iCalendar"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Slot",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Slot",
"path": "Slot",
"short": "A slot of time on a schedule that may be available for booking appointments",
"definition": "A slot of time on a schedule that may be available for booking appointments.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "ical",
"map": "(refer to the Availability resource for the header mapping details)"
},
{
"identity": "w5",
"map": "workflow.scheduling"
}
]
},
{
"id": "Slot.id",
"path": "Slot.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Slot.meta",
"path": "Slot.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Slot.implicitRules",
"path": "Slot.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Slot.language",
"path": "Slot.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Slot.text",
"path": "Slot.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Slot.contained",
"path": "Slot.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Slot.extension",
"path": "Slot.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Slot.modifierExtension",
"path": "Slot.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Slot.identifier",
"path": "Slot.identifier",
"short": "External Ids for this item",
"definition": "External Ids for this item.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Slot.serviceCategory",
"path": "Slot.serviceCategory",
"short": "A broad categorisation of the service that is to be performed during this appointment",
"definition": "A broad categorisation of the service that is to be performed during this appointment.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "service-category"
}
],
"strength": "example",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/service-category"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Slot.serviceType",
"path": "Slot.serviceType",
"short": "The type of appointments that can be booked into this slot (ideally this would be an identifiable service - which is at a location, rather than the location itself). If provided then this overrides the value provided on the availability resource",
"definition": "The type of appointments that can be booked into this slot (ideally this would be an identifiable service - which is at a location, rather than the location itself). If provided then this overrides the value provided on the availability resource.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "service-type"
}
],
"strength": "example",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/service-type"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Slot.specialty",
"path": "Slot.specialty",
"short": "The specialty of a practitioner that would be required to perform the service requested in this appointment",
"definition": "The specialty of a practitioner that would be required to perform the service requested in this appointment.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "specialty"
}
],
"strength": "preferred",
"description": "Additional details about where the content was created (e.g. clinical specialty).",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/c80-practice-codes"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Slot.appointmentType",
"path": "Slot.appointmentType",
"short": "The style of appointment or patient that may be booked in the slot (not service type)",
"definition": "The style of appointment or patient that may be booked in the slot (not service type).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "appointment-type"
}
],
"strength": "preferred",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v2-0276"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Slot.schedule",
"path": "Slot.schedule",
"short": "The schedule resource that this slot defines an interval of status information",
"definition": "The schedule resource that this slot defines an interval of status information.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Schedule"
}
],
"isSummary": true
},
{
"id": "Slot.status",
"path": "Slot.status",
"short": "busy | free | busy-unavailable | busy-tentative | entered-in-error",
"definition": "busy | free | busy-unavailable | busy-tentative | entered-in-error.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SlotStatus"
}
],
"strength": "required",
"description": "The free/busy status of the slot.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/slotstatus"
}
},
"mapping": [
{
"identity": "ical",
"map": "FREEBUSY;FBTYPE=(freeBusyType):19980314T233000Z/19980315T003000Z If the freeBusyType is BUSY, then this value can be excluded"
}
]
},
{
"id": "Slot.start",
"path": "Slot.start",
"short": "Date/Time that the slot is to begin",
"definition": "Date/Time that the slot is to begin.",
"min": 1,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "ical",
"map": "FREEBUSY;FBTYPE=FREE:(start)/19980315T003000Z If the freeBusyType is BUSY, then this value can be excluded"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "Slot.end",
"path": "Slot.end",
"short": "Date/Time that the slot is to conclude",
"definition": "Date/Time that the slot is to conclude.",
"min": 1,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "ical",
"map": "FREEBUSY:19980314T233000Z/(end) If the freeBusyType is BUSY, then this value can be excluded (as shown)"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "Slot.overbooked",
"path": "Slot.overbooked",
"short": "This slot has already been overbooked, appointments are unlikely to be accepted for this time",
"definition": "This slot has already been overbooked, appointments are unlikely to be accepted for this time.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"meaningWhenMissing": "If overbooked is missing, systems may assume that there are still appointments available"
},
{
"id": "Slot.comment",
"path": "Slot.comment",
"short": "Comments on the slot to describe any extended information. Such as custom constraints on the slot",
"definition": "Comments on the slot to describe any extended information. Such as custom constraints on the slot.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Slot",
"path": "Slot",
"short": "A slot of time on a schedule that may be available for booking appointments",
"definition": "A slot of time on a schedule that may be available for booking appointments.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "ical",
"map": "(refer to the Availability resource for the header mapping details)"
},
{
"identity": "w5",
"map": "workflow.scheduling"
}
]
},
{
"id": "Slot.identifier",
"path": "Slot.identifier",
"short": "External Ids for this item",
"definition": "External Ids for this item.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Slot.serviceCategory",
"path": "Slot.serviceCategory",
"short": "A broad categorisation of the service that is to be performed during this appointment",
"definition": "A broad categorisation of the service that is to be performed during this appointment.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "service-category"
}
],
"strength": "example",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/service-category"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Slot.serviceType",
"path": "Slot.serviceType",
"short": "The type of appointments that can be booked into this slot (ideally this would be an identifiable service - which is at a location, rather than the location itself). If provided then this overrides the value provided on the availability resource",
"definition": "The type of appointments that can be booked into this slot (ideally this would be an identifiable service - which is at a location, rather than the location itself). If provided then this overrides the value provided on the availability resource.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "service-type"
}
],
"strength": "example",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/service-type"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Slot.specialty",
"path": "Slot.specialty",
"short": "The specialty of a practitioner that would be required to perform the service requested in this appointment",
"definition": "The specialty of a practitioner that would be required to perform the service requested in this appointment.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "specialty"
}
],
"strength": "preferred",
"description": "Additional details about where the content was created (e.g. clinical specialty).",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/c80-practice-codes"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Slot.appointmentType",
"path": "Slot.appointmentType",
"short": "The style of appointment or patient that may be booked in the slot (not service type)",
"definition": "The style of appointment or patient that may be booked in the slot (not service type).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "appointment-type"
}
],
"strength": "preferred",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v2-0276"
}
},
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Slot.schedule",
"path": "Slot.schedule",
"short": "The schedule resource that this slot defines an interval of status information",
"definition": "The schedule resource that this slot defines an interval of status information.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Schedule"
}
],
"isSummary": true
},
{
"id": "Slot.status",
"path": "Slot.status",
"short": "busy | free | busy-unavailable | busy-tentative | entered-in-error",
"definition": "busy | free | busy-unavailable | busy-tentative | entered-in-error.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SlotStatus"
}
],
"strength": "required",
"description": "The free/busy status of the slot.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/slotstatus"
}
},
"mapping": [
{
"identity": "ical",
"map": "FREEBUSY;FBTYPE=(freeBusyType):19980314T233000Z/19980315T003000Z If the freeBusyType is BUSY, then this value can be excluded"
}
]
},
{
"id": "Slot.start",
"path": "Slot.start",
"short": "Date/Time that the slot is to begin",
"definition": "Date/Time that the slot is to begin.",
"min": 1,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "ical",
"map": "FREEBUSY;FBTYPE=FREE:(start)/19980315T003000Z If the freeBusyType is BUSY, then this value can be excluded"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "Slot.end",
"path": "Slot.end",
"short": "Date/Time that the slot is to conclude",
"definition": "Date/Time that the slot is to conclude.",
"min": 1,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "ical",
"map": "FREEBUSY:19980314T233000Z/(end) If the freeBusyType is BUSY, then this value can be excluded (as shown)"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "Slot.overbooked",
"path": "Slot.overbooked",
"short": "This slot has already been overbooked, appointments are unlikely to be accepted for this time",
"definition": "This slot has already been overbooked, appointments are unlikely to be accepted for this time.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"meaningWhenMissing": "If overbooked is missing, systems may assume that there are still appointments available"
},
{
"id": "Slot.comment",
"path": "Slot.comment",
"short": "Comments on the slot to describe any extended information. Such as custom constraints on the slot",
"definition": "Comments on the slot to describe any extended information. Such as custom constraints on the slot.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Specimen",
"resource": {
"resourceType": "StructureDefinition",
"id": "Specimen",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Specimen DomainResource Sample for analysis
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier External Identifier
accessionIdentifier Σ 0..1 Identifier Identifier assigned by the lab status ?!Σ 0..1 code available | unavailable | unsatisfactory | entered-in-error
SpecimenStatus (Required) type Σ 0..1 CodeableConcept Kind of material that forms the specimen
v2 Specimen Type (Example) subject Σ 1..1 Reference(Patient | Group | Device | Substance) Where the specimen came from. This may be from the patient(s) or from the environment or a device receivedTime Σ 0..1 dateTime The time when specimen was received for processing parent 0..* Reference(Specimen) Specimen from which this specimen originated
request 0..* Reference(ProcedureRequest) Why the specimen was collected
collection 0..1 BackboneElement Collection details collector Σ 0..1 Reference(Practitioner) Who collected the specimen collected[x] Σ 0..1 Collection time collectedDateTime dateTime collectedPeriod Period quantity 0..1 SimpleQuantity The quantity of specimen collected method 0..1 CodeableConcept Technique used to perform collection
FHIR Specimen Collection Method (Example) bodySite 0..1 CodeableConcept Anatomical collection site
SNOMED CT Body Structures (Example) processing 0..* BackboneElement Processing and processing step details
description 0..1 string Textual description of procedure procedure 0..1 CodeableConcept Indicates the treatment step applied to the specimen
SpecimenProcessingProcedure (Example) additive 0..* Reference(Substance) Material used in the processing step
time[x] 0..1 Date and time of specimen processing timeDateTime dateTime timePeriod Period container 0..* BackboneElement Direct container of specimen (tube/slide, etc.)
identifier Σ 0..* Identifier Id for the container
description 0..1 string Textual description of the container type 0..1 CodeableConcept Kind of container directly associated with specimen
SpecimenContainer (Example) capacity 0..1 SimpleQuantity Container volume or size specimenQuantity 0..1 SimpleQuantity Quantity of specimen within container additive[x] 0..1 Additive associated with container
v2 Additive/Preservative (Example) additiveCodeableConcept CodeableConcept additiveReference Reference(Substance) note 0..* Annotation Comments
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "oo"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Specimen",
"name": "Specimen",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Orders and Observations)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/orders/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Specimen Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Specimen",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Specimen",
"path": "Specimen",
"short": "Sample for analysis",
"definition": "A sample to be used for analysis.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "Role[classCode=SPEC]"
},
{
"identity": "w5",
"map": "clinical.diagnostics"
}
]
},
{
"id": "Specimen.id",
"path": "Specimen.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Specimen.meta",
"path": "Specimen.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Specimen.implicitRules",
"path": "Specimen.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Specimen.language",
"path": "Specimen.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Specimen.text",
"path": "Specimen.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Specimen.contained",
"path": "Specimen.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Specimen.extension",
"path": "Specimen.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Specimen.modifierExtension",
"path": "Specimen.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Specimen.identifier",
"path": "Specimen.identifier",
"short": "External Identifier",
"definition": "Id for specimen.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SPM-2"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Specimen.accessionIdentifier",
"path": "Specimen.accessionIdentifier",
"short": "Identifier assigned by the lab",
"definition": "The identifier assigned by the lab when accessioning specimen(s). This is not necessarily the same as the specimen identifier, depending on local lab procedures.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SPM-30 (v2.7+)"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].act[classCode=ACSN, moodCode=EVN].id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Specimen.status",
"path": "Specimen.status",
"short": "available | unavailable | unsatisfactory | entered-in-error",
"definition": "The availability of the specimen.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenStatus"
}
],
"strength": "required",
"description": "Codes providing the status/availability of a specimen.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/specimen-status"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM-20"
},
{
"identity": "rim",
"map": "status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Specimen.type",
"path": "Specimen.type",
"short": "Kind of material that forms the specimen",
"definition": "The kind of material that forms the specimen.",
"comment": "The type can change the way that a specimen is handled, and drives what kind of analyses can properly be performed on the specimen. It is frequently used in diagnostic work flow decision making systems.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenType"
}
],
"strength": "example",
"description": "The type of the specimen.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v2-0487"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM-4 and possibly SPM-5"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Specimen.subject",
"path": "Specimen.subject",
"short": "Where the specimen came from. This may be from the patient(s) or from the environment or a device",
"definition": "Where the specimen came from. This may be from the patient(s) or from the environment or a device.",
"requirements": "Must know the subject context.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".scoper or .scoper.playsRole"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Specimen.receivedTime",
"path": "Specimen.receivedTime",
"short": "The time when specimen was received for processing",
"definition": "Time when specimen was received for processing or testing.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SPM-18"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].act[code=SPCREC, moodCode=EVN].effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Specimen.parent",
"path": "Specimen.parent",
"short": "Specimen from which this specimen originated",
"definition": "Reference to the parent (source) specimen which is used when the specimen was either derived from or a component of another specimen.",
"comment": "The parent specimen could be the source from which the current specimen is derived by some processing step (e.g. an aliquot or isolate or extracted nucleic acids from clinical samples) or one of many specimens that were combined to create a pooled sample.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Specimen"
}
],
"mapping": [
{
"identity": "rim",
"map": ".scoper (if parent) .player.scopesRole[classCode=SPEC].player (if child)"
}
]
},
{
"id": "Specimen.request",
"path": "Specimen.request",
"short": "Why the specimen was collected",
"definition": "Details concerning a test or procedure request that required a specimen to be collected.",
"comment": "The request may be explicit or implied such with a ProcedureRequest that requires a blood draw.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
}
],
"mapping": [
{
"identity": "v2",
"map": "ORC? OBR-2/3?"
},
{
"identity": "rim",
"map": "outboundRelationship[typeCode=FLFS].target"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Specimen.collection",
"path": "Specimen.collection",
"short": "Collection details",
"definition": "Details concerning the specimen collection.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "v2",
"map": "SPM-14"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].act[classCode=SPECCOLLECT, moodCode=EVN]"
}
]
},
{
"id": "Specimen.collection.id",
"path": "Specimen.collection.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Specimen.collection.extension",
"path": "Specimen.collection.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Specimen.collection.modifierExtension",
"path": "Specimen.collection.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Specimen.collection.collector",
"path": "Specimen.collection.collector",
"short": "Who collected the specimen",
"definition": "Person who collected the specimen.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation[typeCode=PFM].role"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Specimen.collection.collected[x]",
"path": "Specimen.collection.collected[x]",
"short": "Collection time",
"definition": "Time when specimen was collected from subject - the physiologically relevant time.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SPM-17"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.init"
}
]
},
{
"id": "Specimen.collection.quantity",
"path": "Specimen.collection.quantity",
"short": "The quantity of specimen collected",
"definition": "The quantity of specimen collected; for instance the volume of a blood sample, or the physical measurement of an anatomic pathology sample.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "SPM-12"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role[classCode=SPEC].player.quantity"
}
]
},
{
"id": "Specimen.collection.method",
"path": "Specimen.collection.method",
"short": "Technique used to perform collection",
"definition": "A coded value specifying the technique that is used to perform the procedure.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenCollectionMethod"
}
],
"strength": "example",
"description": "The technique that is used to perform the procedure",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/specimen-collection-method"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM-7"
},
{
"identity": "rim",
"map": ".methodCode"
}
]
},
{
"id": "Specimen.collection.bodySite",
"path": "Specimen.collection.bodySite",
"short": "Anatomical collection site",
"definition": "Anatomical location from which the specimen was collected (if subject is a patient). This is the target site. This element is not used for environmental specimens.",
"comment": "If the use case requires BodySite to be handled as a separate resource instead of an inline coded element (e.g. to identify and track separately) then use the standard extension [body-site-instance](extension-body-site-instance.html).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "BodySite"
}
],
"strength": "example",
"description": "Codes describing anatomical locations. May include laterality.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/body-site"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM-8 and SPM-9"
},
{
"identity": "rim",
"map": ".targetSiteCode"
}
]
},
{
"id": "Specimen.processing",
"path": "Specimen.processing",
"short": "Processing and processing step details",
"definition": "Details concerning processing and processing steps for the specimen.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].act[code=SPCTRT, moodCode=EVN]"
}
]
},
{
"id": "Specimen.processing.id",
"path": "Specimen.processing.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Specimen.processing.extension",
"path": "Specimen.processing.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Specimen.processing.modifierExtension",
"path": "Specimen.processing.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Specimen.processing.description",
"path": "Specimen.processing.description",
"short": "Textual description of procedure",
"definition": "Textual description of procedure.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "Specimen.processing.procedure",
"path": "Specimen.processing.procedure",
"short": "Indicates the treatment step applied to the specimen",
"definition": "A coded value specifying the procedure used to process the specimen.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenProcessingProcedure"
}
],
"strength": "example",
"description": "Type indicating the technique used to process the specimen",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/specimen-processing-procedure"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "Specimen.processing.additive",
"path": "Specimen.processing.additive",
"short": "Material used in the processing step",
"definition": "Material used in the processing step.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
}
],
"mapping": [
{
"identity": "v2",
"map": "SPM-6"
},
{
"identity": "rim",
"map": ".participation[typeCode=CSM].role[classCode=ADTV].code"
}
]
},
{
"id": "Specimen.processing.time[x]",
"path": "Specimen.processing.time[x]",
"short": "Date and time of specimen processing",
"definition": "A record of the time or period when the specimen processing occurred. For example the time of sample fixation or the period of time the sample was in formalin.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "Specimen.container",
"path": "Specimen.container",
"short": "Direct container of specimen (tube/slide, etc.)",
"definition": "The container holding the specimen. The recursive nature of containers; i.e. blood in tube in tray in rack is not addressed here.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".player.scopingRole[classCode=CONT].scoper"
}
]
},
{
"id": "Specimen.container.id",
"path": "Specimen.container.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Specimen.container.extension",
"path": "Specimen.container.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Specimen.container.modifierExtension",
"path": "Specimen.container.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Specimen.container.identifier",
"path": "Specimen.container.identifier",
"short": "Id for the container",
"definition": "Id for container. There may be multiple; a manufacturer's bar code, lab assigned identifier, etc. The container ID may differ from the specimen id in some circumstances.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SAC-3"
},
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "Specimen.container.description",
"path": "Specimen.container.description",
"short": "Textual description of the container",
"definition": "Textual description of the container.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".desc"
}
]
},
{
"id": "Specimen.container.type",
"path": "Specimen.container.type",
"short": "Kind of container directly associated with specimen",
"definition": "The type of container associated with the specimen (e.g. slide, aliquot, etc.).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenContainerType"
}
],
"strength": "example",
"description": "Type of specimen container",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/specimen-container-type"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM-27"
},
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "Specimen.container.capacity",
"path": "Specimen.container.capacity",
"short": "Container volume or size",
"definition": "The capacity (volume or other measure) the container may contain.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "one of: SAC 16, SAC17 and SAC 20, or SAC 21 and SAC 20"
},
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "Specimen.container.specimenQuantity",
"path": "Specimen.container.specimenQuantity",
"short": "Quantity of specimen within container",
"definition": "The quantity of specimen in the container; may be volume, dimensions, or other appropriate measurements, depending on the specimen type.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "SAC-23 (value) SAC-24 (units"
},
{
"identity": "rim",
"map": ".playedRole[classCode=CONT].quantity"
}
]
},
{
"id": "Specimen.container.additive[x]",
"path": "Specimen.container.additive[x]",
"short": "Additive associated with container",
"definition": "Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenContainerAdditive"
}
],
"strength": "example",
"description": "Substance added to specimen container",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v2-0371"
}
},
"mapping": [
{
"identity": "v2",
"map": "SAC-27"
},
{
"identity": "rim",
"map": ".scopesRole[classCode=ADTV].player"
}
]
},
{
"id": "Specimen.note",
"path": "Specimen.note",
"short": "Comments",
"definition": "To communicate any details or issues about the specimen or during the specimen collection. (for example: broken vial, sent with patient, frozen).",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"annotation\"].value"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Specimen",
"path": "Specimen",
"short": "Sample for analysis",
"definition": "A sample to be used for analysis.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "Role[classCode=SPEC]"
},
{
"identity": "w5",
"map": "clinical.diagnostics"
}
]
},
{
"id": "Specimen.identifier",
"path": "Specimen.identifier",
"short": "External Identifier",
"definition": "Id for specimen.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SPM-2"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Specimen.accessionIdentifier",
"path": "Specimen.accessionIdentifier",
"short": "Identifier assigned by the lab",
"definition": "The identifier assigned by the lab when accessioning specimen(s). This is not necessarily the same as the specimen identifier, depending on local lab procedures.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SPM-30 (v2.7+)"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].act[classCode=ACSN, moodCode=EVN].id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Specimen.status",
"path": "Specimen.status",
"short": "available | unavailable | unsatisfactory | entered-in-error",
"definition": "The availability of the specimen.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenStatus"
}
],
"strength": "required",
"description": "Codes providing the status/availability of a specimen.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/specimen-status"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM-20"
},
{
"identity": "rim",
"map": "status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Specimen.type",
"path": "Specimen.type",
"short": "Kind of material that forms the specimen",
"definition": "The kind of material that forms the specimen.",
"comment": "The type can change the way that a specimen is handled, and drives what kind of analyses can properly be performed on the specimen. It is frequently used in diagnostic work flow decision making systems.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenType"
}
],
"strength": "example",
"description": "The type of the specimen.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v2-0487"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM-4 and possibly SPM-5"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Specimen.subject",
"path": "Specimen.subject",
"short": "Where the specimen came from. This may be from the patient(s) or from the environment or a device",
"definition": "Where the specimen came from. This may be from the patient(s) or from the environment or a device.",
"requirements": "Must know the subject context.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".scoper or .scoper.playsRole"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Specimen.receivedTime",
"path": "Specimen.receivedTime",
"short": "The time when specimen was received for processing",
"definition": "Time when specimen was received for processing or testing.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SPM-18"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].act[code=SPCREC, moodCode=EVN].effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Specimen.parent",
"path": "Specimen.parent",
"short": "Specimen from which this specimen originated",
"definition": "Reference to the parent (source) specimen which is used when the specimen was either derived from or a component of another specimen.",
"comment": "The parent specimen could be the source from which the current specimen is derived by some processing step (e.g. an aliquot or isolate or extracted nucleic acids from clinical samples) or one of many specimens that were combined to create a pooled sample.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Specimen"
}
],
"mapping": [
{
"identity": "rim",
"map": ".scoper (if parent) .player.scopesRole[classCode=SPEC].player (if child)"
}
]
},
{
"id": "Specimen.request",
"path": "Specimen.request",
"short": "Why the specimen was collected",
"definition": "Details concerning a test or procedure request that required a specimen to be collected.",
"comment": "The request may be explicit or implied such with a ProcedureRequest that requires a blood draw.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ProcedureRequest"
}
],
"mapping": [
{
"identity": "v2",
"map": "ORC? OBR-2/3?"
},
{
"identity": "rim",
"map": "outboundRelationship[typeCode=FLFS].target"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Specimen.collection",
"path": "Specimen.collection",
"short": "Collection details",
"definition": "Details concerning the specimen collection.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "v2",
"map": "SPM-14"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].act[classCode=SPECCOLLECT, moodCode=EVN]"
}
]
},
{
"id": "Specimen.collection.collector",
"path": "Specimen.collection.collector",
"short": "Who collected the specimen",
"definition": "Person who collected the specimen.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation[typeCode=PFM].role"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Specimen.collection.collected[x]",
"path": "Specimen.collection.collected[x]",
"short": "Collection time",
"definition": "Time when specimen was collected from subject - the physiologically relevant time.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SPM-17"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.init"
}
]
},
{
"id": "Specimen.collection.quantity",
"path": "Specimen.collection.quantity",
"short": "The quantity of specimen collected",
"definition": "The quantity of specimen collected; for instance the volume of a blood sample, or the physical measurement of an anatomic pathology sample.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "SPM-12"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role[classCode=SPEC].player.quantity"
}
]
},
{
"id": "Specimen.collection.method",
"path": "Specimen.collection.method",
"short": "Technique used to perform collection",
"definition": "A coded value specifying the technique that is used to perform the procedure.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenCollectionMethod"
}
],
"strength": "example",
"description": "The technique that is used to perform the procedure",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/specimen-collection-method"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM-7"
},
{
"identity": "rim",
"map": ".methodCode"
}
]
},
{
"id": "Specimen.collection.bodySite",
"path": "Specimen.collection.bodySite",
"short": "Anatomical collection site",
"definition": "Anatomical location from which the specimen was collected (if subject is a patient). This is the target site. This element is not used for environmental specimens.",
"comment": "If the use case requires BodySite to be handled as a separate resource instead of an inline coded element (e.g. to identify and track separately) then use the standard extension [body-site-instance](extension-body-site-instance.html).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "BodySite"
}
],
"strength": "example",
"description": "Codes describing anatomical locations. May include laterality.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/body-site"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM-8 and SPM-9"
},
{
"identity": "rim",
"map": ".targetSiteCode"
}
]
},
{
"id": "Specimen.processing",
"path": "Specimen.processing",
"short": "Processing and processing step details",
"definition": "Details concerning processing and processing steps for the specimen.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].act[code=SPCTRT, moodCode=EVN]"
}
]
},
{
"id": "Specimen.processing.description",
"path": "Specimen.processing.description",
"short": "Textual description of procedure",
"definition": "Textual description of procedure.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "Specimen.processing.procedure",
"path": "Specimen.processing.procedure",
"short": "Indicates the treatment step applied to the specimen",
"definition": "A coded value specifying the procedure used to process the specimen.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenProcessingProcedure"
}
],
"strength": "example",
"description": "Type indicating the technique used to process the specimen",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/specimen-processing-procedure"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "Specimen.processing.additive",
"path": "Specimen.processing.additive",
"short": "Material used in the processing step",
"definition": "Material used in the processing step.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
}
],
"mapping": [
{
"identity": "v2",
"map": "SPM-6"
},
{
"identity": "rim",
"map": ".participation[typeCode=CSM].role[classCode=ADTV].code"
}
]
},
{
"id": "Specimen.processing.time[x]",
"path": "Specimen.processing.time[x]",
"short": "Date and time of specimen processing",
"definition": "A record of the time or period when the specimen processing occurred. For example the time of sample fixation or the period of time the sample was in formalin.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime"
}
]
},
{
"id": "Specimen.container",
"path": "Specimen.container",
"short": "Direct container of specimen (tube/slide, etc.)",
"definition": "The container holding the specimen. The recursive nature of containers; i.e. blood in tube in tray in rack is not addressed here.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".player.scopingRole[classCode=CONT].scoper"
}
]
},
{
"id": "Specimen.container.identifier",
"path": "Specimen.container.identifier",
"short": "Id for the container",
"definition": "Id for container. There may be multiple; a manufacturer's bar code, lab assigned identifier, etc. The container ID may differ from the specimen id in some circumstances.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "v2",
"map": "SAC-3"
},
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "Specimen.container.description",
"path": "Specimen.container.description",
"short": "Textual description of the container",
"definition": "Textual description of the container.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": ".desc"
}
]
},
{
"id": "Specimen.container.type",
"path": "Specimen.container.type",
"short": "Kind of container directly associated with specimen",
"definition": "The type of container associated with the specimen (e.g. slide, aliquot, etc.).",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenContainerType"
}
],
"strength": "example",
"description": "Type of specimen container",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/specimen-container-type"
}
},
"mapping": [
{
"identity": "v2",
"map": "SPM-27"
},
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "Specimen.container.capacity",
"path": "Specimen.container.capacity",
"short": "Container volume or size",
"definition": "The capacity (volume or other measure) the container may contain.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "one of: SAC 16, SAC17 and SAC 20, or SAC 21 and SAC 20"
},
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "Specimen.container.specimenQuantity",
"path": "Specimen.container.specimenQuantity",
"short": "Quantity of specimen within container",
"definition": "The quantity of specimen in the container; may be volume, dimensions, or other appropriate measurements, depending on the specimen type.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "v2",
"map": "SAC-23 (value) SAC-24 (units"
},
{
"identity": "rim",
"map": ".playedRole[classCode=CONT].quantity"
}
]
},
{
"id": "Specimen.container.additive[x]",
"path": "Specimen.container.additive[x]",
"short": "Additive associated with container",
"definition": "Introduced substance to preserve, maintain or enhance the specimen. Examples: Formalin, Citrate, EDTA.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SpecimenContainerAdditive"
}
],
"strength": "example",
"description": "Substance added to specimen container",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/v2-0371"
}
},
"mapping": [
{
"identity": "v2",
"map": "SAC-27"
},
{
"identity": "rim",
"map": ".scopesRole[classCode=ADTV].player"
}
]
},
{
"id": "Specimen.note",
"path": "Specimen.note",
"short": "Comments",
"definition": "To communicate any details or issues about the specimen or during the specimen collection. (for example: broken vial, sent with patient, frozen).",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "v2",
"map": "OBX"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"annotation\"].value"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/StructureDefinition",
"resource": {
"resourceType": "StructureDefinition",
"id": "StructureDefinition",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints StructureDefinition I DomainResource Structural Definition
+ In any snapshot or differential, no label, code or requirements on the an element without a "." in the path (e.g. the first element)
+ Custom types can only be used in logical models
+ All element definitions must have unique ids (snapshot)
+ Context Invariants can only be used for extensions
+ All element definitions must have unique ids (diff)
+ element.base cannot appear if there is no base on the structure definition
+ If there's a type, its content must match the path name in the first element of a snapshot
+ All element definitions must have an id
+ Element paths must be unique unless the structure is a constraint
+ If the structure describes a base Resource or Type, the URL has to start with "http://hl7.org/fhir/StructureDefinition/" and the tail must match the id
+ A structure must have either a differential, or a snapshot (or both)
+ If the structure defines an extension then the structure must have context information
+ If the structure is not abstract, then there SHALL be a baseDefinition
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension url Σ 1..1 uri Logical URI to reference this structure definition (globally unique) identifier Σ 0..* Identifier Additional identifier for the structure definition
version Σ 0..1 string Business version of the structure definition name Σ 1..1 string Name for this structure definition (computer friendly) title Σ 0..1 string Name for this structure definition (human friendly) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) experimental ?!Σ 0..1 boolean For testing purposes, not real usage date Σ 0..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) contact Σ 0..* ContactDetail Contact details for the publisher
description 0..1 markdown Natural language description of the structure definition useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for structure definition (if applicable)
Jurisdiction ValueSet (Extensible)
purpose 0..1 markdown Why this structure definition is defined copyright 0..1 markdown Use and/or publishing restrictions keyword Σ 0..* Coding Assist with indexing and finding
Structure Definition Codes (Example)
fhirVersion Σ 0..1 id FHIR Version this StructureDefinition targets mapping I 0..* BackboneElement External specification that the content is mapped to
+ Must have at least a name or a uri (or both)
identity 1..1 id Internal id when this mapping is used uri I 0..1 uri Identifies what this mapping refers to name I 0..1 string Names what this mapping refers to comment 0..1 string Versions, Issues, Scope limitations etc. kind Σ 1..1 code primitive-type | complex-type | resource | logical
StructureDefinitionKind (Required) abstract Σ 1..1 boolean Whether the structure is abstract contextType ΣI 0..1 code resource | datatype | extension
ExtensionContext (Required) context ΣI 0..* string Where the extension can be used in instances
contextInvariant ΣI 0..* string FHIRPath invariants - when the extension can be used
type ΣI 1..1 code Type defined or constrained by this structure
FHIRDefinedType (Extensible) baseDefinition ΣI 0..1 uri Definition that this type is constrained/specialized from derivation ΣI 0..1 code specialization | constraint - How relates to base definition
TypeDerivationRule (Required) snapshot I 0..1 BackboneElement Snapshot view of the structure
+ The first element in a snapshot has no type
+ In any snapshot, all the elements must be in the specified type
+ Each element definition in a snapshot must have a formal definition and cardinalities element I 1..* ElementDefinition Definition of elements in the resource (if no StructureDefinition)
differential I 0..1 BackboneElement Differential view of the structure
+ If the first element in a differential has no "." in the path, it has no type
+ No slicing on the root element
+ In any differential, all the elements must be in the specified type element 1..* ElementDefinition Definition of elements in the resource (if no StructureDefinition)
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 5
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/StructureDefinition",
"name": "StructureDefinition",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for StructureDefinition Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "iso11179",
"uri": "http://metadata-standards.org/11179/",
"name": "ISO 11179"
},
{
"identity": "objimpl",
"uri": "http://hl7.org/fhir/object-implementation",
"name": "Object Implementation Information"
}
],
"kind": "resource",
"abstract": false,
"type": "StructureDefinition",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"_baseDefinition": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-codegen-super",
"valueString": "MetadataResource"
}
]
},
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "StructureDefinition",
"path": "StructureDefinition",
"short": "Structural Definition",
"definition": "A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types.",
"alias": [
"Template",
"Profile"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "sdf-9",
"requirements": "Because these 3 fields seem to be have overlapping meaning with the ones in the root of StructureDefinition",
"severity": "error",
"human": "In any snapshot or differential, no label, code or requirements on the an element without a \".\" in the path (e.g. the first element)",
"expression": "children().element.first().label.empty() and children().element.first().code.empty() and children().element.first().requirements.empty()",
"xpath": "not(exists(f:snapshot/f:element[not(contains(f:path/@value, '.')) and (f:label or f:code or f:requirements)])) and not(exists(f:differential/f:element[not(contains(f:path/@value, '.')) and (f:label or f:code or f:requirements)]))"
},
{
"key": "sdf-19",
"requirements": "custom types only in logical models",
"severity": "error",
"human": "Custom types can only be used in logical models",
"expression": "kind = 'logical' or (differential.element.type.code.all(hasValue() implies matches('^[a-zA-Z0-9]+$')) and snapshot.element.type.code.all(hasValue() implies matches('^[a-zA-Z0-9]+$')))",
"xpath": "f:kind/@value = 'logical' or count(f:differential/f:element/f:type/f:code[@value and not(matches(string(@value), '^[a-zA-Z0-9]+$'))]|f:snapshot/f:element/f:type/f:code[@value and not(matches(string(@value), '^[a-zA-Z0-9]+$'))]) =0"
},
{
"key": "sdf-16",
"requirements": "element ids need to be unique",
"severity": "error",
"human": "All element definitions must have unique ids (snapshot)",
"expression": "snapshot.element.id.trace('ids').isDistinct()",
"xpath": "count(*/f:element)=count(*/f:element/@id)"
},
{
"key": "sdf-18",
"requirements": "contextInvariant",
"severity": "error",
"human": "Context Invariants can only be used for extensions",
"expression": "contextInvariant.exists() implies type = 'Extension'",
"xpath": "not(exists(f:contextInvariant)) or (f:type/@value = 'Extension')"
},
{
"key": "sdf-17",
"requirements": "element ids need to be unique",
"severity": "error",
"human": "All element definitions must have unique ids (diff)",
"expression": "differential.element.id.trace('ids').isDistinct()",
"xpath": "count(*/f:element)=count(*/f:element/@id)"
},
{
"key": "sdf-12",
"requirements": "Ensure that element.base appears with base or not",
"severity": "error",
"human": "element.base cannot appear if there is no base on the structure definition",
"expression": "snapshot.exists() implies (snapshot.element.base.exists() = baseDefinition.exists())",
"xpath": "f:baseDefinition or not(exists(f:snapshot/f:element/f:base) or exists(f:differential/f:element/f:base))"
},
{
"key": "sdf-11",
"requirements": "Ensure that the type is not inconsistent with the other information in the structure",
"severity": "error",
"human": "If there's a type, its content must match the path name in the first element of a snapshot",
"expression": "snapshot.empty() or snapshot.element.first().path = type",
"xpath": "not(exists(f:snapshot)) or (f:type/@value = f:snapshot/f:element[1]/f:path/@value)"
},
{
"key": "sdf-14",
"requirements": "elements have id",
"severity": "error",
"human": "All element definitions must have an id",
"expression": "snapshot.element.all(id.exists()) and differential.element.all(id.exists())",
"xpath": "count(*/f:element)=count(*/f:element/@id)"
},
{
"key": "sdf-1",
"severity": "error",
"human": "Element paths must be unique unless the structure is a constraint",
"expression": "derivation = 'constraint' or snapshot.element.select(path).isDistinct()",
"xpath": "(f:derivation/@value = 'constraint') or (count(f:snapshot/f:element) = count(distinct-values(f:snapshot/f:element/f:path/@value)))"
},
{
"key": "sdf-7",
"severity": "error",
"human": "If the structure describes a base Resource or Type, the URL has to start with \"http://hl7.org/fhir/StructureDefinition/\" and the tail must match the id",
"expression": "(derivation = 'constraint') or (kind = 'logical') or (url = 'http://hl7.org/fhir/StructureDefinition/'+id)",
"xpath": "(f:derivation/@value = 'constraint') or (f:kind/@value = 'logical') or (f:url/@value=concat('http://hl7.org/fhir/StructureDefinition/', f:id/@value))"
},
{
"key": "sdf-6",
"severity": "error",
"human": "A structure must have either a differential, or a snapshot (or both)",
"expression": "snapshot.exists() or differential.exists()",
"xpath": "exists(f:snapshot) or exists(f:differential)"
},
{
"key": "sdf-5",
"severity": "error",
"human": "If the structure defines an extension then the structure must have context information",
"expression": "type != 'Extension' or derivation = 'specialization' or (context.exists() and contextType.exists())",
"xpath": "not(f:type/@value = 'extension') or (f:derivation/@value = 'specialization') or (exists(f:context) and exists(f:contextType))"
},
{
"key": "sdf-4",
"requirements": "Ensure that the base types are abstract",
"severity": "error",
"human": "If the structure is not abstract, then there SHALL be a baseDefinition",
"expression": "abstract = true or baseDefinition.exists()",
"xpath": "(f:abstract/@value=true()) or exists(f:baseDefinition)"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "conformance.content"
}
]
},
{
"id": "StructureDefinition.id",
"path": "StructureDefinition.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.meta",
"path": "StructureDefinition.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.implicitRules",
"path": "StructureDefinition.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "StructureDefinition.language",
"path": "StructureDefinition.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "StructureDefinition.text",
"path": "StructureDefinition.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "StructureDefinition.contained",
"path": "StructureDefinition.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureDefinition.extension",
"path": "StructureDefinition.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureDefinition.modifierExtension",
"path": "StructureDefinition.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureDefinition.url",
"path": "StructureDefinition.url",
"short": "Logical URI to reference this structure definition (globally unique)",
"definition": "An absolute URI that is used to identify this structure definition when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this structure definition is (or will be) published. The URL SHOULD include the major version of the structure definition. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the structure definition to be referenced by a single globally unique identifier.",
"alias": [
"url",
"authoritative-url",
"destination",
"identity"
],
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "StructureDefinition.identifier",
"path": "StructureDefinition.identifier",
"short": "Additional identifier for the structure definition",
"definition": "A formal identifier that is used to identify this structure definition when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this structure definition outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "iso11179",
"map": "Identifier part"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "StructureDefinition.version",
"path": "StructureDefinition.version",
"short": "Business version of the structure definition",
"definition": "The identifier that is used to identify this version of the structure definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different structure definition instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the structure definition with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "iso11179",
"map": "Version"
},
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "StructureDefinition.name",
"path": "StructureDefinition.name",
"short": "Name for this structure definition (computer friendly)",
"definition": "A natural language name identifying the structure definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.title",
"path": "StructureDefinition.title",
"short": "Name for this structure definition (human friendly)",
"definition": "A short, descriptive, user-friendly title for the structure definition.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc. Applications don't have to use this name, but can always fall back to it. The title also corresponds to the label for the root element.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.status",
"path": "StructureDefinition.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this structure definition. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of structure definitions that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired structure definition without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "iso11179",
"map": "Registration status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "StructureDefinition.experimental",
"path": "StructureDefinition.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this structure definition is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of structure definition that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental structure definition in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level structure definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "iso11179",
"map": "Registration status"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "StructureDefinition.date",
"path": "StructureDefinition.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the structure definition was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure definition changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the structure definition. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "StructureDefinition.publisher",
"path": "StructureDefinition.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the structure definition.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the structure definition is the organization or individual primarily responsible for the maintenance and upkeep of the structure definition. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the structure definition. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the structure definition. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "iso11179",
"map": "Registration Authority"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "StructureDefinition.contact",
"path": "StructureDefinition.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.description",
"path": "StructureDefinition.description",
"short": "Natural language description of the structure definition",
"definition": "A free text natural language description of the structure definition from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the structure definition was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the structure definition as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "StructureDefinition.useContext",
"path": "StructureDefinition.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate structure definition instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.jurisdiction",
"path": "StructureDefinition.jurisdiction",
"short": "Intended jurisdiction for structure definition (if applicable)",
"definition": "A legal or geographic region in which the structure definition is intended to be used.",
"comment": "It may be possible for the structure definition to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "StructureDefinition.purpose",
"path": "StructureDefinition.purpose",
"short": "Why this structure definition is defined",
"definition": "Explaination of why this structure definition is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the structure definition Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this structure definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "StructureDefinition.copyright",
"path": "StructureDefinition.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the structure definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure definition.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the structure definition and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "StructureDefinition.keyword",
"path": "StructureDefinition.keyword",
"short": "Assist with indexing and finding",
"definition": "A set of key words or terms from external terminologies that may be used to assist with indexing and searching of templates.",
"requirements": "Assist in searching for appropriate StructureDefinitions.",
"min": 0,
"max": "*",
"type": [
{
"code": "Coding"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureDefinitionCode"
}
],
"strength": "example",
"description": "Codes for the meaning of the defined structure (SNOMED CT and LOINC codes, as an example).",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/profile-code"
}
},
"mapping": [
{
"identity": "iso11179",
"map": "keywords"
}
]
},
{
"id": "StructureDefinition.fhirVersion",
"path": "StructureDefinition.fhirVersion",
"short": "FHIR Version this StructureDefinition targets",
"definition": "The version of the FHIR specification on which this StructureDefinition is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 3.0.1 for this version.",
"comment": "A StructureDefinition does not need to specify the target it applies to,as StructureDefinitions will often be valid across multiple versions of FHIR. FHIR tooling can determine whether a StructureDefinition is consistent with a particular StructureDefinition if desired.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.mapping",
"path": "StructureDefinition.mapping",
"short": "External specification that the content is mapped to",
"definition": "An external specification that the content is mapped to.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "sdf-2",
"severity": "error",
"human": "Must have at least a name or a uri (or both)",
"expression": "name.exists() or uri.exists()",
"xpath": "exists(f:uri) or exists(f:name)"
}
]
},
{
"id": "StructureDefinition.mapping.id",
"path": "StructureDefinition.mapping.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureDefinition.mapping.extension",
"path": "StructureDefinition.mapping.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureDefinition.mapping.modifierExtension",
"path": "StructureDefinition.mapping.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureDefinition.mapping.identity",
"path": "StructureDefinition.mapping.identity",
"short": "Internal id when this mapping is used",
"definition": "An Internal id that is used to identify this mapping set when specific mappings are made.",
"comment": "The specification is described once, with general comments, and then specific mappings are made that reference this declaration.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "StructureDefinition.mapping.uri",
"path": "StructureDefinition.mapping.uri",
"short": "Identifies what this mapping refers to",
"definition": "An absolute URI that identifies the specification that this mapping is expressed to.",
"comment": "A formal identity for the specification being mapped to helps with identifying maps consistently.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"condition": [
"sdf-2"
]
},
{
"id": "StructureDefinition.mapping.name",
"path": "StructureDefinition.mapping.name",
"short": "Names what this mapping refers to",
"definition": "A name for the specification that is being mapped to.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"sdf-2"
]
},
{
"id": "StructureDefinition.mapping.comment",
"path": "StructureDefinition.mapping.comment",
"short": "Versions, Issues, Scope limitations etc.",
"definition": "Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "StructureDefinition.kind",
"path": "StructureDefinition.kind",
"short": "primitive-type | complex-type | resource | logical",
"definition": "Defines the kind of structure that this definition is describing.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureDefinitionKind"
}
],
"strength": "required",
"description": "Defines the type of structure that a definition is describing.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/structure-definition-kind"
}
}
},
{
"id": "StructureDefinition.abstract",
"path": "StructureDefinition.abstract",
"short": "Whether the structure is abstract",
"definition": "Whether structure this definition describes is abstract or not - that is, whether the structure is not intended to be instantiated. For Resources and Data types, abstract types will never be exchanged between systems.",
"comment": "Abstract Resources cannot be instantiated - a concrete sub-type must be used. Abstract datatypes and extensions cannot be used in an instance. For logical models, the exact implication of \"abstract\" will rest with the author, depending how the logical model is used. Flagging a constraint structure as abstract conveys design intent but makes no difference to how the structure definition is handled. Note that inline declared elements that are given the type \"Element\" in the profile, but have children described, are anonymous concrete types that specialise Element.",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.contextType",
"path": "StructureDefinition.contextType",
"short": "resource | datatype | extension",
"definition": "If this is an extension, Identifies the context within FHIR resources where the extension can be used.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"sdf-5"
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ExtensionContext"
}
],
"strength": "required",
"description": "How an extension context is interpreted.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/extension-context"
}
}
},
{
"id": "StructureDefinition.context",
"path": "StructureDefinition.context",
"short": "Where the extension can be used in instances",
"definition": "Identifies the types of resource or data type elements to which the extension can be applied.",
"comment": "If the context is an element that can have multiple types, then use (e.g.) value[x] if the extension works on all choice types, or otherwise an enumeration of explicitly named elements if not. Note that a context of \"string\" doesn't mean that the extension can be used with one of the string patterns such as \"id\" etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"condition": [
"sdf-5"
],
"isSummary": true
},
{
"id": "StructureDefinition.contextInvariant",
"path": "StructureDefinition.contextInvariant",
"short": "FHIRPath invariants - when the extension can be used",
"definition": "A set of rules as Fluent Invariants about when the extension can be used (e.g. co-occurrence variants for the extension).",
"comment": "All the rules must be true. When evaluating the invariant, the fluentpath focus is the element that holds the extension, and %extension refers to the extension itself.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"condition": [
"sdf-18"
],
"isSummary": true
},
{
"id": "StructureDefinition.type",
"path": "StructureDefinition.type",
"short": "Type defined or constrained by this structure",
"definition": "The type this structure describes. If the derivation kind is 'specialization' then this is the master definition for a type, and there is always one of these (a data type, an extension, a resource, including abstract ones). Otherwise the structure definition is a constraint on the stated type (and in this case, the type cannot be an abstract type).",
"comment": "Note that in the case of constraints, the type could be determined by chasing through the baseDefinition references until a concrete structure (derivation = specialization) is reached, or by looking at the path of the first element in the snapshot - if present - but providing the type directly makes for simpler tooling and indexing.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"sdf-4",
"sdf-11"
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FHIRDefinedTypeExt"
}
],
"strength": "extensible",
"description": "Either a resource or a data type, including logical model types",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/defined-types"
}
}
},
{
"id": "StructureDefinition.baseDefinition",
"path": "StructureDefinition.baseDefinition",
"short": "Definition that this type is constrained/specialized from",
"definition": "An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.",
"comment": "If differential constraints are specified in this structure, they are applied to the base in a \"differential\" fashion. If there is no base, then the differential constraints cannot be provided (snapshot only). Differential structures are useful for the editing perspective, and snapshot structures are suitable for operational use. The FHIR Project provides a number of tools/services to populate snapshots from differential constraints. Logical Models have a base of \"Element\" or another logical model.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"condition": [
"sdf-4"
],
"isSummary": true
},
{
"id": "StructureDefinition.derivation",
"path": "StructureDefinition.derivation",
"short": "specialization | constraint - How relates to base definition",
"definition": "How the type relates to the baseDefinition.",
"comment": "If the definition is a specialization, then it adds new elements in the differential, and the snapshot includes the inherited elements.\n\nIf the definition is a constraint, then it can not define new elements, it can only make new rules about existing content (see [Profiling Resources](profiling.html#resources)).",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"sdf-12"
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TypeDerivationRule"
}
],
"strength": "required",
"description": "How a type relates to its baseDefinition.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/type-derivation-rule"
}
}
},
{
"id": "StructureDefinition.snapshot",
"path": "StructureDefinition.snapshot",
"short": "Snapshot view of the structure",
"definition": "A snapshot view is expressed in a stand alone form that can be used and interpreted without considering the base StructureDefinition.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"sdf-6"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "sdf-15",
"requirements": "No Type on the root element (snapshot)",
"severity": "error",
"human": "The first element in a snapshot has no type",
"expression": "element.first().type.empty()",
"xpath": "not(f:element[1]/f:type)"
},
{
"key": "sdf-8",
"severity": "error",
"human": "In any snapshot, all the elements must be in the specified type",
"expression": "element.first().path = %resource.type and element.tail().all(path.startsWith(%resource.type&'.'))",
"xpath": "f:element[1]/f:path/@value=parent::f:StructureDefinition/f:type/@value and count(f:element[position()!=1])=count(f:element[position()!=1][starts-with(f:path/@value, concat(ancestor::f:StructureDefinition/f:type/@value, '.'))])"
},
{
"key": "sdf-3",
"severity": "error",
"human": "Each element definition in a snapshot must have a formal definition and cardinalities",
"expression": "element.all(definition and min and max)",
"xpath": "count(f:element) = count(f:element[exists(f:definition) and exists(f:min) and exists(f:max)])"
}
]
},
{
"id": "StructureDefinition.snapshot.id",
"path": "StructureDefinition.snapshot.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureDefinition.snapshot.extension",
"path": "StructureDefinition.snapshot.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureDefinition.snapshot.modifierExtension",
"path": "StructureDefinition.snapshot.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureDefinition.snapshot.element",
"path": "StructureDefinition.snapshot.element",
"short": "Definition of elements in the resource (if no StructureDefinition)",
"definition": "Captures constraints on each element within the resource.",
"min": 1,
"max": "*",
"type": [
{
"code": "ElementDefinition"
}
],
"condition": [
"sdf-3"
],
"mapping": [
{
"identity": "iso11179",
"map": "--"
}
]
},
{
"id": "StructureDefinition.differential",
"path": "StructureDefinition.differential",
"short": "Differential view of the structure",
"definition": "A differential view is expressed relative to the base StructureDefinition - a statement of differences that it applies.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"sdf-6"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "sdf-15a",
"requirements": "No Type on the root element (differential)",
"severity": "error",
"human": "If the first element in a differential has no \".\" in the path, it has no type",
"expression": "element.first().path.contains('.').not() implies element.first().type.empty()",
"xpath": "not(f:element[1][not(contains(f:path/@value, '.'))]/f:type)"
},
{
"key": "sdf-20",
"requirements": "no slicing on root",
"severity": "error",
"human": "No slicing on the root element",
"expression": "element.first().slicing.empty()",
"xpath": "not(f:element[1]/f:slicing)"
},
{
"key": "sdf-8a",
"severity": "error",
"human": "In any differential, all the elements must be in the specified type",
"expression": "element.first().path.startsWith(%resource.type) and element.tail().all(path.startsWith(%resource.type&'.'))",
"xpath": "count(f:element)=count(f:element[f:path/@value=ancestor::f:StructureDefinition/f:type/@value or starts-with(f:path/@value, concat(ancestor::f:StructureDefinition/f:type/@value, '.'))])"
}
]
},
{
"id": "StructureDefinition.differential.id",
"path": "StructureDefinition.differential.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureDefinition.differential.extension",
"path": "StructureDefinition.differential.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureDefinition.differential.modifierExtension",
"path": "StructureDefinition.differential.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureDefinition.differential.element",
"path": "StructureDefinition.differential.element",
"short": "Definition of elements in the resource (if no StructureDefinition)",
"definition": "Captures constraints on each element within the resource.",
"min": 1,
"max": "*",
"type": [
{
"code": "ElementDefinition"
}
],
"mapping": [
{
"identity": "iso11179",
"map": "--"
}
]
}
]
},
"differential": {
"element": [
{
"id": "StructureDefinition",
"path": "StructureDefinition",
"short": "Structural Definition",
"definition": "A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types.",
"alias": [
"Template",
"Profile"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "sdf-9",
"requirements": "Because these 3 fields seem to be have overlapping meaning with the ones in the root of StructureDefinition",
"severity": "error",
"human": "In any snapshot or differential, no label, code or requirements on the an element without a \".\" in the path (e.g. the first element)",
"expression": "children().element.first().label.empty() and children().element.first().code.empty() and children().element.first().requirements.empty()",
"xpath": "not(exists(f:snapshot/f:element[not(contains(f:path/@value, '.')) and (f:label or f:code or f:requirements)])) and not(exists(f:differential/f:element[not(contains(f:path/@value, '.')) and (f:label or f:code or f:requirements)]))"
},
{
"key": "sdf-19",
"requirements": "custom types only in logical models",
"severity": "error",
"human": "Custom types can only be used in logical models",
"expression": "kind = 'logical' or (differential.element.type.code.all(hasValue() implies matches('^[a-zA-Z0-9]+$')) and snapshot.element.type.code.all(hasValue() implies matches('^[a-zA-Z0-9]+$')))",
"xpath": "f:kind/@value = 'logical' or count(f:differential/f:element/f:type/f:code[@value and not(matches(string(@value), '^[a-zA-Z0-9]+$'))]|f:snapshot/f:element/f:type/f:code[@value and not(matches(string(@value), '^[a-zA-Z0-9]+$'))]) =0"
},
{
"key": "sdf-16",
"requirements": "element ids need to be unique",
"severity": "error",
"human": "All element definitions must have unique ids (snapshot)",
"expression": "snapshot.element.id.trace('ids').isDistinct()",
"xpath": "count(*/f:element)=count(*/f:element/@id)"
},
{
"key": "sdf-18",
"requirements": "contextInvariant",
"severity": "error",
"human": "Context Invariants can only be used for extensions",
"expression": "contextInvariant.exists() implies type = 'Extension'",
"xpath": "not(exists(f:contextInvariant)) or (f:type/@value = 'Extension')"
},
{
"key": "sdf-17",
"requirements": "element ids need to be unique",
"severity": "error",
"human": "All element definitions must have unique ids (diff)",
"expression": "differential.element.id.trace('ids').isDistinct()",
"xpath": "count(*/f:element)=count(*/f:element/@id)"
},
{
"key": "sdf-12",
"requirements": "Ensure that element.base appears with base or not",
"severity": "error",
"human": "element.base cannot appear if there is no base on the structure definition",
"expression": "snapshot.exists() implies (snapshot.element.base.exists() = baseDefinition.exists())",
"xpath": "f:baseDefinition or not(exists(f:snapshot/f:element/f:base) or exists(f:differential/f:element/f:base))"
},
{
"key": "sdf-11",
"requirements": "Ensure that the type is not inconsistent with the other information in the structure",
"severity": "error",
"human": "If there's a type, its content must match the path name in the first element of a snapshot",
"expression": "snapshot.empty() or snapshot.element.first().path = type",
"xpath": "not(exists(f:snapshot)) or (f:type/@value = f:snapshot/f:element[1]/f:path/@value)"
},
{
"key": "sdf-14",
"requirements": "elements have id",
"severity": "error",
"human": "All element definitions must have an id",
"expression": "snapshot.element.all(id.exists()) and differential.element.all(id.exists())",
"xpath": "count(*/f:element)=count(*/f:element/@id)"
},
{
"key": "sdf-1",
"severity": "error",
"human": "Element paths must be unique unless the structure is a constraint",
"expression": "derivation = 'constraint' or snapshot.element.select(path).isDistinct()",
"xpath": "(f:derivation/@value = 'constraint') or (count(f:snapshot/f:element) = count(distinct-values(f:snapshot/f:element/f:path/@value)))"
},
{
"key": "sdf-7",
"severity": "error",
"human": "If the structure describes a base Resource or Type, the URL has to start with \"http://hl7.org/fhir/StructureDefinition/\" and the tail must match the id",
"expression": "(derivation = 'constraint') or (kind = 'logical') or (url = 'http://hl7.org/fhir/StructureDefinition/'+id)",
"xpath": "(f:derivation/@value = 'constraint') or (f:kind/@value = 'logical') or (f:url/@value=concat('http://hl7.org/fhir/StructureDefinition/', f:id/@value))"
},
{
"key": "sdf-6",
"severity": "error",
"human": "A structure must have either a differential, or a snapshot (or both)",
"expression": "snapshot.exists() or differential.exists()",
"xpath": "exists(f:snapshot) or exists(f:differential)"
},
{
"key": "sdf-5",
"severity": "error",
"human": "If the structure defines an extension then the structure must have context information",
"expression": "type != 'Extension' or derivation = 'specialization' or (context.exists() and contextType.exists())",
"xpath": "not(f:type/@value = 'extension') or (f:derivation/@value = 'specialization') or (exists(f:context) and exists(f:contextType))"
},
{
"key": "sdf-4",
"requirements": "Ensure that the base types are abstract",
"severity": "error",
"human": "If the structure is not abstract, then there SHALL be a baseDefinition",
"expression": "abstract = true or baseDefinition.exists()",
"xpath": "(f:abstract/@value=true()) or exists(f:baseDefinition)"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "conformance.content"
}
]
},
{
"id": "StructureDefinition.url",
"path": "StructureDefinition.url",
"short": "Logical URI to reference this structure definition (globally unique)",
"definition": "An absolute URI that is used to identify this structure definition when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this structure definition is (or will be) published. The URL SHOULD include the major version of the structure definition. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the structure definition to be referenced by a single globally unique identifier.",
"alias": [
"url",
"authoritative-url",
"destination",
"identity"
],
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "StructureDefinition.identifier",
"path": "StructureDefinition.identifier",
"short": "Additional identifier for the structure definition",
"definition": "A formal identifier that is used to identify this structure definition when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this structure definition outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "iso11179",
"map": "Identifier part"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "StructureDefinition.version",
"path": "StructureDefinition.version",
"short": "Business version of the structure definition",
"definition": "The identifier that is used to identify this version of the structure definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure definition author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different structure definition instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the structure definition with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "iso11179",
"map": "Version"
},
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "StructureDefinition.name",
"path": "StructureDefinition.name",
"short": "Name for this structure definition (computer friendly)",
"definition": "A natural language name identifying the structure definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.title",
"path": "StructureDefinition.title",
"short": "Name for this structure definition (human friendly)",
"definition": "A short, descriptive, user-friendly title for the structure definition.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc. Applications don't have to use this name, but can always fall back to it. The title also corresponds to the label for the root element.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.status",
"path": "StructureDefinition.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this structure definition. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of structure definitions that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired structure definition without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "iso11179",
"map": "Registration status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "StructureDefinition.experimental",
"path": "StructureDefinition.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this structure definition is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of structure definition that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental structure definition in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level structure definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "iso11179",
"map": "Registration status"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "StructureDefinition.date",
"path": "StructureDefinition.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the structure definition was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure definition changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the structure definition. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "StructureDefinition.publisher",
"path": "StructureDefinition.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the structure definition.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the structure definition is the organization or individual primarily responsible for the maintenance and upkeep of the structure definition. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the structure definition. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the structure definition. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "iso11179",
"map": "Registration Authority"
},
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "StructureDefinition.contact",
"path": "StructureDefinition.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.description",
"path": "StructureDefinition.description",
"short": "Natural language description of the structure definition",
"definition": "A free text natural language description of the structure definition from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the structure definition was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the structure definition as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "StructureDefinition.useContext",
"path": "StructureDefinition.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate structure definition instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.jurisdiction",
"path": "StructureDefinition.jurisdiction",
"short": "Intended jurisdiction for structure definition (if applicable)",
"definition": "A legal or geographic region in which the structure definition is intended to be used.",
"comment": "It may be possible for the structure definition to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "StructureDefinition.purpose",
"path": "StructureDefinition.purpose",
"short": "Why this structure definition is defined",
"definition": "Explaination of why this structure definition is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the structure definition Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this structure definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "StructureDefinition.copyright",
"path": "StructureDefinition.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the structure definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure definition.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the structure definition and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "StructureDefinition.keyword",
"path": "StructureDefinition.keyword",
"short": "Assist with indexing and finding",
"definition": "A set of key words or terms from external terminologies that may be used to assist with indexing and searching of templates.",
"requirements": "Assist in searching for appropriate StructureDefinitions.",
"min": 0,
"max": "*",
"type": [
{
"code": "Coding"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureDefinitionCode"
}
],
"strength": "example",
"description": "Codes for the meaning of the defined structure (SNOMED CT and LOINC codes, as an example).",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/profile-code"
}
},
"mapping": [
{
"identity": "iso11179",
"map": "keywords"
}
]
},
{
"id": "StructureDefinition.fhirVersion",
"path": "StructureDefinition.fhirVersion",
"short": "FHIR Version this StructureDefinition targets",
"definition": "The version of the FHIR specification on which this StructureDefinition is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 3.0.1 for this version.",
"comment": "A StructureDefinition does not need to specify the target it applies to,as StructureDefinitions will often be valid across multiple versions of FHIR. FHIR tooling can determine whether a StructureDefinition is consistent with a particular StructureDefinition if desired.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.mapping",
"path": "StructureDefinition.mapping",
"short": "External specification that the content is mapped to",
"definition": "An external specification that the content is mapped to.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "sdf-2",
"severity": "error",
"human": "Must have at least a name or a uri (or both)",
"expression": "name.exists() or uri.exists()",
"xpath": "exists(f:uri) or exists(f:name)"
}
]
},
{
"id": "StructureDefinition.mapping.identity",
"path": "StructureDefinition.mapping.identity",
"short": "Internal id when this mapping is used",
"definition": "An Internal id that is used to identify this mapping set when specific mappings are made.",
"comment": "The specification is described once, with general comments, and then specific mappings are made that reference this declaration.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "StructureDefinition.mapping.uri",
"path": "StructureDefinition.mapping.uri",
"short": "Identifies what this mapping refers to",
"definition": "An absolute URI that identifies the specification that this mapping is expressed to.",
"comment": "A formal identity for the specification being mapped to helps with identifying maps consistently.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"condition": [
"sdf-2"
]
},
{
"id": "StructureDefinition.mapping.name",
"path": "StructureDefinition.mapping.name",
"short": "Names what this mapping refers to",
"definition": "A name for the specification that is being mapped to.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"sdf-2"
]
},
{
"id": "StructureDefinition.mapping.comment",
"path": "StructureDefinition.mapping.comment",
"short": "Versions, Issues, Scope limitations etc.",
"definition": "Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "StructureDefinition.kind",
"path": "StructureDefinition.kind",
"short": "primitive-type | complex-type | resource | logical",
"definition": "Defines the kind of structure that this definition is describing.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureDefinitionKind"
}
],
"strength": "required",
"description": "Defines the type of structure that a definition is describing.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/structure-definition-kind"
}
}
},
{
"id": "StructureDefinition.abstract",
"path": "StructureDefinition.abstract",
"short": "Whether the structure is abstract",
"definition": "Whether structure this definition describes is abstract or not - that is, whether the structure is not intended to be instantiated. For Resources and Data types, abstract types will never be exchanged between systems.",
"comment": "Abstract Resources cannot be instantiated - a concrete sub-type must be used. Abstract datatypes and extensions cannot be used in an instance. For logical models, the exact implication of \"abstract\" will rest with the author, depending how the logical model is used. Flagging a constraint structure as abstract conveys design intent but makes no difference to how the structure definition is handled. Note that inline declared elements that are given the type \"Element\" in the profile, but have children described, are anonymous concrete types that specialise Element.",
"min": 1,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "StructureDefinition.contextType",
"path": "StructureDefinition.contextType",
"short": "resource | datatype | extension",
"definition": "If this is an extension, Identifies the context within FHIR resources where the extension can be used.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"sdf-5"
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ExtensionContext"
}
],
"strength": "required",
"description": "How an extension context is interpreted.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/extension-context"
}
}
},
{
"id": "StructureDefinition.context",
"path": "StructureDefinition.context",
"short": "Where the extension can be used in instances",
"definition": "Identifies the types of resource or data type elements to which the extension can be applied.",
"comment": "If the context is an element that can have multiple types, then use (e.g.) value[x] if the extension works on all choice types, or otherwise an enumeration of explicitly named elements if not. Note that a context of \"string\" doesn't mean that the extension can be used with one of the string patterns such as \"id\" etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"condition": [
"sdf-5"
],
"isSummary": true
},
{
"id": "StructureDefinition.contextInvariant",
"path": "StructureDefinition.contextInvariant",
"short": "FHIRPath invariants - when the extension can be used",
"definition": "A set of rules as Fluent Invariants about when the extension can be used (e.g. co-occurrence variants for the extension).",
"comment": "All the rules must be true. When evaluating the invariant, the fluentpath focus is the element that holds the extension, and %extension refers to the extension itself.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"condition": [
"sdf-18"
],
"isSummary": true
},
{
"id": "StructureDefinition.type",
"path": "StructureDefinition.type",
"short": "Type defined or constrained by this structure",
"definition": "The type this structure describes. If the derivation kind is 'specialization' then this is the master definition for a type, and there is always one of these (a data type, an extension, a resource, including abstract ones). Otherwise the structure definition is a constraint on the stated type (and in this case, the type cannot be an abstract type).",
"comment": "Note that in the case of constraints, the type could be determined by chasing through the baseDefinition references until a concrete structure (derivation = specialization) is reached, or by looking at the path of the first element in the snapshot - if present - but providing the type directly makes for simpler tooling and indexing.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"sdf-4",
"sdf-11"
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FHIRDefinedTypeExt"
}
],
"strength": "extensible",
"description": "Either a resource or a data type, including logical model types",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/defined-types"
}
}
},
{
"id": "StructureDefinition.baseDefinition",
"path": "StructureDefinition.baseDefinition",
"short": "Definition that this type is constrained/specialized from",
"definition": "An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.",
"comment": "If differential constraints are specified in this structure, they are applied to the base in a \"differential\" fashion. If there is no base, then the differential constraints cannot be provided (snapshot only). Differential structures are useful for the editing perspective, and snapshot structures are suitable for operational use. The FHIR Project provides a number of tools/services to populate snapshots from differential constraints. Logical Models have a base of \"Element\" or another logical model.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"condition": [
"sdf-4"
],
"isSummary": true
},
{
"id": "StructureDefinition.derivation",
"path": "StructureDefinition.derivation",
"short": "specialization | constraint - How relates to base definition",
"definition": "How the type relates to the baseDefinition.",
"comment": "If the definition is a specialization, then it adds new elements in the differential, and the snapshot includes the inherited elements.\n\nIf the definition is a constraint, then it can not define new elements, it can only make new rules about existing content (see [Profiling Resources](profiling.html#resources)).",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"sdf-12"
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TypeDerivationRule"
}
],
"strength": "required",
"description": "How a type relates to its baseDefinition.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/type-derivation-rule"
}
}
},
{
"id": "StructureDefinition.snapshot",
"path": "StructureDefinition.snapshot",
"short": "Snapshot view of the structure",
"definition": "A snapshot view is expressed in a stand alone form that can be used and interpreted without considering the base StructureDefinition.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"sdf-6"
],
"constraint": [
{
"key": "sdf-15",
"requirements": "No Type on the root element (snapshot)",
"severity": "error",
"human": "The first element in a snapshot has no type",
"expression": "element.first().type.empty()",
"xpath": "not(f:element[1]/f:type)"
},
{
"key": "sdf-8",
"severity": "error",
"human": "In any snapshot, all the elements must be in the specified type",
"expression": "element.first().path = %resource.type and element.tail().all(path.startsWith(%resource.type&'.'))",
"xpath": "f:element[1]/f:path/@value=parent::f:StructureDefinition/f:type/@value and count(f:element[position()!=1])=count(f:element[position()!=1][starts-with(f:path/@value, concat(ancestor::f:StructureDefinition/f:type/@value, '.'))])"
},
{
"key": "sdf-3",
"severity": "error",
"human": "Each element definition in a snapshot must have a formal definition and cardinalities",
"expression": "element.all(definition and min and max)",
"xpath": "count(f:element) = count(f:element[exists(f:definition) and exists(f:min) and exists(f:max)])"
}
]
},
{
"id": "StructureDefinition.snapshot.element",
"path": "StructureDefinition.snapshot.element",
"short": "Definition of elements in the resource (if no StructureDefinition)",
"definition": "Captures constraints on each element within the resource.",
"min": 1,
"max": "*",
"type": [
{
"code": "ElementDefinition"
}
],
"condition": [
"sdf-3"
],
"mapping": [
{
"identity": "iso11179",
"map": "--"
}
]
},
{
"id": "StructureDefinition.differential",
"path": "StructureDefinition.differential",
"short": "Differential view of the structure",
"definition": "A differential view is expressed relative to the base StructureDefinition - a statement of differences that it applies.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"sdf-6"
],
"constraint": [
{
"key": "sdf-15a",
"requirements": "No Type on the root element (differential)",
"severity": "error",
"human": "If the first element in a differential has no \".\" in the path, it has no type",
"expression": "element.first().path.contains('.').not() implies element.first().type.empty()",
"xpath": "not(f:element[1][not(contains(f:path/@value, '.'))]/f:type)"
},
{
"key": "sdf-20",
"requirements": "no slicing on root",
"severity": "error",
"human": "No slicing on the root element",
"expression": "element.first().slicing.empty()",
"xpath": "not(f:element[1]/f:slicing)"
},
{
"key": "sdf-8a",
"severity": "error",
"human": "In any differential, all the elements must be in the specified type",
"expression": "element.first().path.startsWith(%resource.type) and element.tail().all(path.startsWith(%resource.type&'.'))",
"xpath": "count(f:element)=count(f:element[f:path/@value=ancestor::f:StructureDefinition/f:type/@value or starts-with(f:path/@value, concat(ancestor::f:StructureDefinition/f:type/@value, '.'))])"
}
]
},
{
"id": "StructureDefinition.differential.element",
"path": "StructureDefinition.differential.element",
"short": "Definition of elements in the resource (if no StructureDefinition)",
"definition": "Captures constraints on each element within the resource.",
"min": 1,
"max": "*",
"type": [
{
"code": "ElementDefinition"
}
],
"mapping": [
{
"identity": "iso11179",
"map": "--"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/StructureMap",
"resource": {
"resourceType": "StructureDefinition",
"id": "StructureMap",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints StructureMap DomainResource A Map of relationships between 2 structures that can be used to transform data
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension url Σ 1..1 uri Logical URI to reference this structure map (globally unique) identifier Σ 0..* Identifier Additional identifier for the structure map
version Σ 0..1 string Business version of the structure map name Σ 1..1 string Name for this structure map (computer friendly) title Σ 0..1 string Name for this structure map (human friendly) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) experimental ?!Σ 0..1 boolean For testing purposes, not real usage date Σ 0..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) contact Σ 0..* ContactDetail Contact details for the publisher
description 0..1 markdown Natural language description of the structure map useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for structure map (if applicable)
Jurisdiction ValueSet (Extensible)
purpose 0..1 markdown Why this structure map is defined copyright 0..1 markdown Use and/or publishing restrictions structure Σ 0..* BackboneElement Structure Definition used by this map
url Σ 1..1 uri Canonical URL for structure definition mode Σ 1..1 code source | queried | target | produced
StructureMapModelMode (Required) alias Σ 0..1 string Name for type in this map documentation 0..1 string Documentation on use of structure import Σ 0..* uri Other maps used by this map (canonical URLs)
group Σ 1..* BackboneElement Named sections for reader convenience
name Σ 1..1 id Human-readable label extends Σ 0..1 id Another group that this group adds rules to typeMode Σ 1..1 code none | types | type-and-types
StructureMapGroupTypeMode (Required) documentation Σ 0..1 string Additional description/explaination for group input Σ 1..* BackboneElement Named instance provided when invoking the map
name Σ 1..1 id Name for this instance of data type Σ 0..1 string Type for this instance of data mode Σ 1..1 code source | target
StructureMapInputMode (Required) documentation 0..1 string Documentation for this instance of data rule Σ 1..* BackboneElement Transform Rule from source to target
name Σ 1..1 id Name of the rule for internal references source Σ 1..* BackboneElement Source inputs to the mapping
context Σ 1..1 id Type or variable this rule applies to min Σ 0..1 integer Specified minimum cardinality max Σ 0..1 string Specified maximum cardinality (number or *) type Σ 0..1 string Rule only applies if source has this type defaultValue[x] Σ 0..1 * Default value if no value exists element Σ 0..1 string Optional field for this source listMode Σ 0..1 code first | not_first | last | not_last | only_one
StructureMapSourceListMode (Required) variable Σ 0..1 id Named context for field, if a field is specified condition Σ 0..1 string FHIRPath expression - must be true or the rule does not apply check Σ 0..1 string FHIRPath expression - must be true or the mapping engine throws an error instead of completing target ΣI 0..* BackboneElement Content to create because of this mapping rule
+ Must have a contextType if you have a context
+ Can only have a element if you have a context
context Σ 0..1 id Type or variable this rule applies to contextType Σ 0..1 code type | variable
StructureMapContextType (Required) element Σ 0..1 string Field to create in the context variable Σ 0..1 id Named context for field, if desired, and a field is specified listMode Σ 0..* code first | share | last | collate
StructureMapTargetListMode (Required)
listRuleId Σ 0..1 id Internal rule reference for shared list items transform Σ 0..1 code create | copy +
StructureMapTransform (Required) parameter Σ 0..* BackboneElement Parameters to the transform
value[x] Σ 1..1 Parameter value - variable or literal valueId id valueString string valueBoolean boolean valueInteger integer valueDecimal decimal rule Σ 0..* see rule Rules contained in this rule
dependent Σ 0..* BackboneElement Which other rules to apply in the context of this rule
name Σ 1..1 id Name of a rule or group to apply variable Σ 1..* string Variable to pass to the rule or group
documentation 0..1 string Documentation for this instance of data
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/StructureMap",
"name": "StructureMap",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for StructureMap Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "objimpl",
"uri": "http://hl7.org/fhir/object-implementation",
"name": "Object Implementation Information"
}
],
"kind": "resource",
"abstract": false,
"type": "StructureMap",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"_baseDefinition": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-codegen-super",
"valueString": "MetadataResource"
}
]
},
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "StructureMap",
"path": "StructureMap",
"short": "A Map of relationships between 2 structures that can be used to transform data",
"definition": "A Map of relationships between 2 structures that can be used to transform data.",
"alias": [
"Template",
"Profile"
],
"min": 1,
"max": "1",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "conformance.content"
}
]
},
{
"id": "StructureMap.id",
"path": "StructureMap.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.meta",
"path": "StructureMap.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "StructureMap.implicitRules",
"path": "StructureMap.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "StructureMap.language",
"path": "StructureMap.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "StructureMap.text",
"path": "StructureMap.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "StructureMap.contained",
"path": "StructureMap.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureMap.extension",
"path": "StructureMap.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureMap.modifierExtension",
"path": "StructureMap.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureMap.url",
"path": "StructureMap.url",
"short": "Logical URI to reference this structure map (globally unique)",
"definition": "An absolute URI that is used to identify this structure map when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this structure map is (or will be) published. The URL SHOULD include the major version of the structure map. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the structure map to be referenced by a single globally unique identifier.",
"alias": [
"url",
"authoritative-url",
"destination",
"identity"
],
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "StructureMap.identifier",
"path": "StructureMap.identifier",
"short": "Additional identifier for the structure map",
"definition": "A formal identifier that is used to identify this structure map when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this structure map outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "StructureMap.version",
"path": "StructureMap.version",
"short": "Business version of the structure map",
"definition": "The identifier that is used to identify this version of the structure map when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure map author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different structure map instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the structure map with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "StructureMap.name",
"path": "StructureMap.name",
"short": "Name for this structure map (computer friendly)",
"definition": "A natural language name identifying the structure map. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.title",
"path": "StructureMap.title",
"short": "Name for this structure map (human friendly)",
"definition": "A short, descriptive, user-friendly title for the structure map.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.status",
"path": "StructureMap.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this structure map. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of structure maps that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired structure map without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "StructureMap.experimental",
"path": "StructureMap.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this structure map is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of structure map that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental structure map in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level structure map.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "StructureMap.date",
"path": "StructureMap.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the structure map was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure map changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the structure map. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "StructureMap.publisher",
"path": "StructureMap.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the structure map.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the structure map is the organization or individual primarily responsible for the maintenance and upkeep of the structure map. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the structure map. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the structure map. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "StructureMap.contact",
"path": "StructureMap.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "StructureMap.description",
"path": "StructureMap.description",
"short": "Natural language description of the structure map",
"definition": "A free text natural language description of the structure map from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the structure map was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the structure map as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "StructureMap.useContext",
"path": "StructureMap.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate structure map instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "StructureMap.jurisdiction",
"path": "StructureMap.jurisdiction",
"short": "Intended jurisdiction for structure map (if applicable)",
"definition": "A legal or geographic region in which the structure map is intended to be used.",
"comment": "It may be possible for the structure map to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "StructureMap.purpose",
"path": "StructureMap.purpose",
"short": "Why this structure map is defined",
"definition": "Explaination of why this structure map is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the structure map Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this structure map.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "StructureMap.copyright",
"path": "StructureMap.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the structure map and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure map.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the structure map and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "StructureMap.structure",
"path": "StructureMap.structure",
"short": "Structure Definition used by this map",
"definition": "A structure definition used by this map. The structure definition may describe instances that are converted, or the instances that are produced.",
"comment": "It is not necessary for a structure map to identify any dependent structures, though not losting them may restrict its usefulness.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true
},
{
"id": "StructureMap.structure.id",
"path": "StructureMap.structure.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.structure.extension",
"path": "StructureMap.structure.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.structure.modifierExtension",
"path": "StructureMap.structure.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureMap.structure.url",
"path": "StructureMap.structure.url",
"short": "Canonical URL for structure definition",
"definition": "The canonical URL that identifies the structure.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true
},
{
"id": "StructureMap.structure.mode",
"path": "StructureMap.structure.mode",
"short": "source | queried | target | produced",
"definition": "How the referenced structure is used in this mapping.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapModelMode"
}
],
"strength": "required",
"description": "How the referenced structure is used in this mapping",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-model-mode"
}
}
},
{
"id": "StructureMap.structure.alias",
"path": "StructureMap.structure.alias",
"short": "Name for type in this map",
"definition": "The name used for this type in the map.",
"comment": "This is needed if both types have the same name (e.g. version conversion).",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.structure.documentation",
"path": "StructureMap.structure.documentation",
"short": "Documentation on use of structure",
"definition": "Documentation that describes how the structure is used in the mapping.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "StructureMap.import",
"path": "StructureMap.import",
"short": "Other maps used by this map (canonical URLs)",
"definition": "Other maps used by this map (canonical URLs).",
"min": 0,
"max": "*",
"type": [
{
"code": "uri"
}
],
"isSummary": true
},
{
"id": "StructureMap.group",
"path": "StructureMap.group",
"short": "Named sections for reader convenience",
"definition": "Organizes the mapping into managable chunks for human review/ease of maintenance.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.id",
"path": "StructureMap.group.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.extension",
"path": "StructureMap.group.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.modifierExtension",
"path": "StructureMap.group.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureMap.group.name",
"path": "StructureMap.group.name",
"short": "Human-readable label",
"definition": "A unique name for the group for the convenience of human readers.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.extends",
"path": "StructureMap.group.extends",
"short": "Another group that this group adds rules to",
"definition": "Another group that this group adds rules to.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.typeMode",
"path": "StructureMap.group.typeMode",
"short": "none | types | type-and-types",
"definition": "If this is the default rule set to apply for thie source type, or this combination of types.",
"comment": "Not applicable if the underlying model is untyped. There can only be one default mapping for any particular type combination.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapGroupTypeMode"
}
],
"strength": "required",
"description": "If this is the default rule set to apply for the source type, or this combination of types",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-group-type-mode"
}
}
},
{
"id": "StructureMap.group.documentation",
"path": "StructureMap.group.documentation",
"short": "Additional description/explaination for group",
"definition": "Additional supporting documentation that explains the purpose of the group and the types of mappings within it.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.input",
"path": "StructureMap.group.input",
"short": "Named instance provided when invoking the map",
"definition": "A name assigned to an instance of data. The instance must be provided when the mapping is invoked.",
"comment": "If no inputs are named, then the entry mappings are type based.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.input.id",
"path": "StructureMap.group.input.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.input.extension",
"path": "StructureMap.group.input.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.input.modifierExtension",
"path": "StructureMap.group.input.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureMap.group.input.name",
"path": "StructureMap.group.input.name",
"short": "Name for this instance of data",
"definition": "Name for this instance of data.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.input.type",
"path": "StructureMap.group.input.type",
"short": "Type for this instance of data",
"definition": "Type for this instance of data.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.input.mode",
"path": "StructureMap.group.input.mode",
"short": "source | target",
"definition": "Mode for this instance of data.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapInputMode"
}
],
"strength": "required",
"description": "Mode for this instance of data",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-input-mode"
}
}
},
{
"id": "StructureMap.group.input.documentation",
"path": "StructureMap.group.input.documentation",
"short": "Documentation for this instance of data",
"definition": "Documentation for this instance of data.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "StructureMap.group.rule",
"path": "StructureMap.group.rule",
"short": "Transform Rule from source to target",
"definition": "Transform Rule from source to target.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.id",
"path": "StructureMap.group.rule.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.rule.extension",
"path": "StructureMap.group.rule.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.rule.modifierExtension",
"path": "StructureMap.group.rule.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureMap.group.rule.name",
"path": "StructureMap.group.rule.name",
"short": "Name of the rule for internal references",
"definition": "Name of the rule for internal references.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source",
"path": "StructureMap.group.rule.source",
"short": "Source inputs to the mapping",
"definition": "Source inputs to the mapping.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.id",
"path": "StructureMap.group.rule.source.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.rule.source.extension",
"path": "StructureMap.group.rule.source.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.rule.source.modifierExtension",
"path": "StructureMap.group.rule.source.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureMap.group.rule.source.context",
"path": "StructureMap.group.rule.source.context",
"short": "Type or variable this rule applies to",
"definition": "Type or variable this rule applies to.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.min",
"path": "StructureMap.group.rule.source.min",
"short": "Specified minimum cardinality",
"definition": "Specified minimum cardinality for the element. This is optional; if present, it acts an implicit check on the input content.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.max",
"path": "StructureMap.group.rule.source.max",
"short": "Specified maximum cardinality (number or *)",
"definition": "Specified maximum cardinality for the element - a number or a \"*\". This is optional; if present, it acts an implicit check on the input content (* just serves as documentation; it's the default value).",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.type",
"path": "StructureMap.group.rule.source.type",
"short": "Rule only applies if source has this type",
"definition": "Specified type for the element. This works as a condition on the mapping - use for polymorphic elements.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.defaultValue[x]",
"path": "StructureMap.group.rule.source.defaultValue[x]",
"short": "Default value if no value exists",
"definition": "A value to use if there is no existing value in the source object.",
"comment": "If there's a default value on an item that can repeat, it will only be used once.",
"min": 0,
"max": "1",
"type": [
{
"code": "base64Binary"
},
{
"code": "boolean"
},
{
"code": "code"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "decimal"
},
{
"code": "id"
},
{
"code": "instant"
},
{
"code": "integer"
},
{
"code": "markdown"
},
{
"code": "oid"
},
{
"code": "positiveInt"
},
{
"code": "string"
},
{
"code": "time"
},
{
"code": "unsignedInt"
},
{
"code": "uri"
},
{
"code": "Address"
},
{
"code": "Age"
},
{
"code": "Annotation"
},
{
"code": "Attachment"
},
{
"code": "CodeableConcept"
},
{
"code": "Coding"
},
{
"code": "ContactPoint"
},
{
"code": "Count"
},
{
"code": "Distance"
},
{
"code": "Duration"
},
{
"code": "HumanName"
},
{
"code": "Identifier"
},
{
"code": "Money"
},
{
"code": "Period"
},
{
"code": "Quantity"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "Reference"
},
{
"code": "SampledData"
},
{
"code": "Signature"
},
{
"code": "Timing"
},
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.element",
"path": "StructureMap.group.rule.source.element",
"short": "Optional field for this source",
"definition": "Optional field for this source.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.listMode",
"path": "StructureMap.group.rule.source.listMode",
"short": "first | not_first | last | not_last | only_one",
"definition": "How to handle the list mode for this element.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapSourceListMode"
}
],
"strength": "required",
"description": "If field is a list, how to manage the source",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-source-list-mode"
}
}
},
{
"id": "StructureMap.group.rule.source.variable",
"path": "StructureMap.group.rule.source.variable",
"short": "Named context for field, if a field is specified",
"definition": "Named context for field, if a field is specified.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.condition",
"path": "StructureMap.group.rule.source.condition",
"short": "FHIRPath expression - must be true or the rule does not apply",
"definition": "FHIRPath expression - must be true or the rule does not apply.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.check",
"path": "StructureMap.group.rule.source.check",
"short": "FHIRPath expression - must be true or the mapping engine throws an error instead of completing",
"definition": "FHIRPath expression - must be true or the mapping engine throws an error instead of completing.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target",
"path": "StructureMap.group.rule.target",
"short": "Content to create because of this mapping rule",
"definition": "Content to create because of this mapping rule.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "smp-2",
"severity": "error",
"human": "Must have a contextType if you have a context",
"expression": "context.exists() implies contextType.exists()",
"xpath": "not(f:context) or (f:contextType)"
},
{
"key": "smp-1",
"severity": "error",
"human": "Can only have a element if you have a context",
"expression": "element.exists() implies context.exists()",
"xpath": "not(f:element) or (f:context)"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.id",
"path": "StructureMap.group.rule.target.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.rule.target.extension",
"path": "StructureMap.group.rule.target.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.rule.target.modifierExtension",
"path": "StructureMap.group.rule.target.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureMap.group.rule.target.context",
"path": "StructureMap.group.rule.target.context",
"short": "Type or variable this rule applies to",
"definition": "Type or variable this rule applies to.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.contextType",
"path": "StructureMap.group.rule.target.contextType",
"short": "type | variable",
"definition": "How to interpret the context.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapContextType"
}
],
"strength": "required",
"description": "How to interpret the context",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-context-type"
}
}
},
{
"id": "StructureMap.group.rule.target.element",
"path": "StructureMap.group.rule.target.element",
"short": "Field to create in the context",
"definition": "Field to create in the context.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.variable",
"path": "StructureMap.group.rule.target.variable",
"short": "Named context for field, if desired, and a field is specified",
"definition": "Named context for field, if desired, and a field is specified.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.listMode",
"path": "StructureMap.group.rule.target.listMode",
"short": "first | share | last | collate",
"definition": "If field is a list, how to manage the list.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapTargetListMode"
}
],
"strength": "required",
"description": "If field is a list, how to manage the production",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-target-list-mode"
}
}
},
{
"id": "StructureMap.group.rule.target.listRuleId",
"path": "StructureMap.group.rule.target.listRuleId",
"short": "Internal rule reference for shared list items",
"definition": "Internal rule reference for shared list items.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.transform",
"path": "StructureMap.group.rule.target.transform",
"short": "create | copy +",
"definition": "How the data is copied / created.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapTransform"
}
],
"strength": "required",
"description": "How data is copied/created",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-transform"
}
}
},
{
"id": "StructureMap.group.rule.target.parameter",
"path": "StructureMap.group.rule.target.parameter",
"short": "Parameters to the transform",
"definition": "Parameters to the transform.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.parameter.id",
"path": "StructureMap.group.rule.target.parameter.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.rule.target.parameter.extension",
"path": "StructureMap.group.rule.target.parameter.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.rule.target.parameter.modifierExtension",
"path": "StructureMap.group.rule.target.parameter.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureMap.group.rule.target.parameter.value[x]",
"path": "StructureMap.group.rule.target.parameter.value[x]",
"short": "Parameter value - variable or literal",
"definition": "Parameter value - variable or literal.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
},
{
"code": "string"
},
{
"code": "boolean"
},
{
"code": "integer"
},
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.rule",
"path": "StructureMap.group.rule.rule",
"short": "Rules contained in this rule",
"definition": "Rules contained in this rule.",
"min": 0,
"max": "*",
"contentReference": "#StructureMap.group.rule",
"isSummary": true
},
{
"id": "StructureMap.group.rule.dependent",
"path": "StructureMap.group.rule.dependent",
"short": "Which other rules to apply in the context of this rule",
"definition": "Which other rules to apply in the context of this rule.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.dependent.id",
"path": "StructureMap.group.rule.dependent.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.rule.dependent.extension",
"path": "StructureMap.group.rule.dependent.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "StructureMap.group.rule.dependent.modifierExtension",
"path": "StructureMap.group.rule.dependent.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "StructureMap.group.rule.dependent.name",
"path": "StructureMap.group.rule.dependent.name",
"short": "Name of a rule or group to apply",
"definition": "Name of a rule or group to apply.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.dependent.variable",
"path": "StructureMap.group.rule.dependent.variable",
"short": "Variable to pass to the rule or group",
"definition": "Variable to pass to the rule or group.",
"min": 1,
"max": "*",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.documentation",
"path": "StructureMap.group.rule.documentation",
"short": "Documentation for this instance of data",
"definition": "Documentation for this instance of data.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
}
]
},
"differential": {
"element": [
{
"id": "StructureMap",
"path": "StructureMap",
"short": "A Map of relationships between 2 structures that can be used to transform data",
"definition": "A Map of relationships between 2 structures that can be used to transform data.",
"alias": [
"Template",
"Profile"
],
"min": 1,
"max": "1",
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "conformance.content"
}
]
},
{
"id": "StructureMap.url",
"path": "StructureMap.url",
"short": "Logical URI to reference this structure map (globally unique)",
"definition": "An absolute URI that is used to identify this structure map when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this structure map is (or will be) published. The URL SHOULD include the major version of the structure map. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the structure map to be referenced by a single globally unique identifier.",
"alias": [
"url",
"authoritative-url",
"destination",
"identity"
],
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "StructureMap.identifier",
"path": "StructureMap.identifier",
"short": "Additional identifier for the structure map",
"definition": "A formal identifier that is used to identify this structure map when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this structure map outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "StructureMap.version",
"path": "StructureMap.version",
"short": "Business version of the structure map",
"definition": "The identifier that is used to identify this version of the structure map when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure map author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different structure map instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the structure map with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "StructureMap.name",
"path": "StructureMap.name",
"short": "Name for this structure map (computer friendly)",
"definition": "A natural language name identifying the structure map. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.title",
"path": "StructureMap.title",
"short": "Name for this structure map (human friendly)",
"definition": "A short, descriptive, user-friendly title for the structure map.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.status",
"path": "StructureMap.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this structure map. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of structure maps that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired structure map without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "StructureMap.experimental",
"path": "StructureMap.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this structure map is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of structure map that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental structure map in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level structure map.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "StructureMap.date",
"path": "StructureMap.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the structure map was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the structure map changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the structure map. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "StructureMap.publisher",
"path": "StructureMap.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the structure map.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the structure map is the organization or individual primarily responsible for the maintenance and upkeep of the structure map. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the structure map. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the structure map. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "StructureMap.contact",
"path": "StructureMap.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "StructureMap.description",
"path": "StructureMap.description",
"short": "Natural language description of the structure map",
"definition": "A free text natural language description of the structure map from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the structure map was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the structure map as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "StructureMap.useContext",
"path": "StructureMap.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate structure map instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "StructureMap.jurisdiction",
"path": "StructureMap.jurisdiction",
"short": "Intended jurisdiction for structure map (if applicable)",
"definition": "A legal or geographic region in which the structure map is intended to be used.",
"comment": "It may be possible for the structure map to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "StructureMap.purpose",
"path": "StructureMap.purpose",
"short": "Why this structure map is defined",
"definition": "Explaination of why this structure map is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the structure map Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this structure map.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "StructureMap.copyright",
"path": "StructureMap.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the structure map and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure map.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the structure map and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "StructureMap.structure",
"path": "StructureMap.structure",
"short": "Structure Definition used by this map",
"definition": "A structure definition used by this map. The structure definition may describe instances that are converted, or the instances that are produced.",
"comment": "It is not necessary for a structure map to identify any dependent structures, though not losting them may restrict its usefulness.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true
},
{
"id": "StructureMap.structure.url",
"path": "StructureMap.structure.url",
"short": "Canonical URL for structure definition",
"definition": "The canonical URL that identifies the structure.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true
},
{
"id": "StructureMap.structure.mode",
"path": "StructureMap.structure.mode",
"short": "source | queried | target | produced",
"definition": "How the referenced structure is used in this mapping.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapModelMode"
}
],
"strength": "required",
"description": "How the referenced structure is used in this mapping",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-model-mode"
}
}
},
{
"id": "StructureMap.structure.alias",
"path": "StructureMap.structure.alias",
"short": "Name for type in this map",
"definition": "The name used for this type in the map.",
"comment": "This is needed if both types have the same name (e.g. version conversion).",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.structure.documentation",
"path": "StructureMap.structure.documentation",
"short": "Documentation on use of structure",
"definition": "Documentation that describes how the structure is used in the mapping.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "StructureMap.import",
"path": "StructureMap.import",
"short": "Other maps used by this map (canonical URLs)",
"definition": "Other maps used by this map (canonical URLs).",
"min": 0,
"max": "*",
"type": [
{
"code": "uri"
}
],
"isSummary": true
},
{
"id": "StructureMap.group",
"path": "StructureMap.group",
"short": "Named sections for reader convenience",
"definition": "Organizes the mapping into managable chunks for human review/ease of maintenance.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.name",
"path": "StructureMap.group.name",
"short": "Human-readable label",
"definition": "A unique name for the group for the convenience of human readers.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.extends",
"path": "StructureMap.group.extends",
"short": "Another group that this group adds rules to",
"definition": "Another group that this group adds rules to.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.typeMode",
"path": "StructureMap.group.typeMode",
"short": "none | types | type-and-types",
"definition": "If this is the default rule set to apply for thie source type, or this combination of types.",
"comment": "Not applicable if the underlying model is untyped. There can only be one default mapping for any particular type combination.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapGroupTypeMode"
}
],
"strength": "required",
"description": "If this is the default rule set to apply for the source type, or this combination of types",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-group-type-mode"
}
}
},
{
"id": "StructureMap.group.documentation",
"path": "StructureMap.group.documentation",
"short": "Additional description/explaination for group",
"definition": "Additional supporting documentation that explains the purpose of the group and the types of mappings within it.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.input",
"path": "StructureMap.group.input",
"short": "Named instance provided when invoking the map",
"definition": "A name assigned to an instance of data. The instance must be provided when the mapping is invoked.",
"comment": "If no inputs are named, then the entry mappings are type based.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.input.name",
"path": "StructureMap.group.input.name",
"short": "Name for this instance of data",
"definition": "Name for this instance of data.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.input.type",
"path": "StructureMap.group.input.type",
"short": "Type for this instance of data",
"definition": "Type for this instance of data.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.input.mode",
"path": "StructureMap.group.input.mode",
"short": "source | target",
"definition": "Mode for this instance of data.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapInputMode"
}
],
"strength": "required",
"description": "Mode for this instance of data",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-input-mode"
}
}
},
{
"id": "StructureMap.group.input.documentation",
"path": "StructureMap.group.input.documentation",
"short": "Documentation for this instance of data",
"definition": "Documentation for this instance of data.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "StructureMap.group.rule",
"path": "StructureMap.group.rule",
"short": "Transform Rule from source to target",
"definition": "Transform Rule from source to target.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.name",
"path": "StructureMap.group.rule.name",
"short": "Name of the rule for internal references",
"definition": "Name of the rule for internal references.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source",
"path": "StructureMap.group.rule.source",
"short": "Source inputs to the mapping",
"definition": "Source inputs to the mapping.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.context",
"path": "StructureMap.group.rule.source.context",
"short": "Type or variable this rule applies to",
"definition": "Type or variable this rule applies to.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.min",
"path": "StructureMap.group.rule.source.min",
"short": "Specified minimum cardinality",
"definition": "Specified minimum cardinality for the element. This is optional; if present, it acts an implicit check on the input content.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.max",
"path": "StructureMap.group.rule.source.max",
"short": "Specified maximum cardinality (number or *)",
"definition": "Specified maximum cardinality for the element - a number or a \"*\". This is optional; if present, it acts an implicit check on the input content (* just serves as documentation; it's the default value).",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.type",
"path": "StructureMap.group.rule.source.type",
"short": "Rule only applies if source has this type",
"definition": "Specified type for the element. This works as a condition on the mapping - use for polymorphic elements.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.defaultValue[x]",
"path": "StructureMap.group.rule.source.defaultValue[x]",
"short": "Default value if no value exists",
"definition": "A value to use if there is no existing value in the source object.",
"comment": "If there's a default value on an item that can repeat, it will only be used once.",
"min": 0,
"max": "1",
"type": [
{
"code": "base64Binary"
},
{
"code": "boolean"
},
{
"code": "code"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "decimal"
},
{
"code": "id"
},
{
"code": "instant"
},
{
"code": "integer"
},
{
"code": "markdown"
},
{
"code": "oid"
},
{
"code": "positiveInt"
},
{
"code": "string"
},
{
"code": "time"
},
{
"code": "unsignedInt"
},
{
"code": "uri"
},
{
"code": "Address"
},
{
"code": "Age"
},
{
"code": "Annotation"
},
{
"code": "Attachment"
},
{
"code": "CodeableConcept"
},
{
"code": "Coding"
},
{
"code": "ContactPoint"
},
{
"code": "Count"
},
{
"code": "Distance"
},
{
"code": "Duration"
},
{
"code": "HumanName"
},
{
"code": "Identifier"
},
{
"code": "Money"
},
{
"code": "Period"
},
{
"code": "Quantity"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "Reference"
},
{
"code": "SampledData"
},
{
"code": "Signature"
},
{
"code": "Timing"
},
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.element",
"path": "StructureMap.group.rule.source.element",
"short": "Optional field for this source",
"definition": "Optional field for this source.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.listMode",
"path": "StructureMap.group.rule.source.listMode",
"short": "first | not_first | last | not_last | only_one",
"definition": "How to handle the list mode for this element.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapSourceListMode"
}
],
"strength": "required",
"description": "If field is a list, how to manage the source",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-source-list-mode"
}
}
},
{
"id": "StructureMap.group.rule.source.variable",
"path": "StructureMap.group.rule.source.variable",
"short": "Named context for field, if a field is specified",
"definition": "Named context for field, if a field is specified.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.condition",
"path": "StructureMap.group.rule.source.condition",
"short": "FHIRPath expression - must be true or the rule does not apply",
"definition": "FHIRPath expression - must be true or the rule does not apply.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.source.check",
"path": "StructureMap.group.rule.source.check",
"short": "FHIRPath expression - must be true or the mapping engine throws an error instead of completing",
"definition": "FHIRPath expression - must be true or the mapping engine throws an error instead of completing.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target",
"path": "StructureMap.group.rule.target",
"short": "Content to create because of this mapping rule",
"definition": "Content to create because of this mapping rule.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "smp-2",
"severity": "error",
"human": "Must have a contextType if you have a context",
"expression": "context.exists() implies contextType.exists()",
"xpath": "not(f:context) or (f:contextType)"
},
{
"key": "smp-1",
"severity": "error",
"human": "Can only have a element if you have a context",
"expression": "element.exists() implies context.exists()",
"xpath": "not(f:element) or (f:context)"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.context",
"path": "StructureMap.group.rule.target.context",
"short": "Type or variable this rule applies to",
"definition": "Type or variable this rule applies to.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.contextType",
"path": "StructureMap.group.rule.target.contextType",
"short": "type | variable",
"definition": "How to interpret the context.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapContextType"
}
],
"strength": "required",
"description": "How to interpret the context",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-context-type"
}
}
},
{
"id": "StructureMap.group.rule.target.element",
"path": "StructureMap.group.rule.target.element",
"short": "Field to create in the context",
"definition": "Field to create in the context.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.variable",
"path": "StructureMap.group.rule.target.variable",
"short": "Named context for field, if desired, and a field is specified",
"definition": "Named context for field, if desired, and a field is specified.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.listMode",
"path": "StructureMap.group.rule.target.listMode",
"short": "first | share | last | collate",
"definition": "If field is a list, how to manage the list.",
"min": 0,
"max": "*",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapTargetListMode"
}
],
"strength": "required",
"description": "If field is a list, how to manage the production",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-target-list-mode"
}
}
},
{
"id": "StructureMap.group.rule.target.listRuleId",
"path": "StructureMap.group.rule.target.listRuleId",
"short": "Internal rule reference for shared list items",
"definition": "Internal rule reference for shared list items.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.transform",
"path": "StructureMap.group.rule.target.transform",
"short": "create | copy +",
"definition": "How the data is copied / created.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "StructureMapTransform"
}
],
"strength": "required",
"description": "How data is copied/created",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/map-transform"
}
}
},
{
"id": "StructureMap.group.rule.target.parameter",
"path": "StructureMap.group.rule.target.parameter",
"short": "Parameters to the transform",
"definition": "Parameters to the transform.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.target.parameter.value[x]",
"path": "StructureMap.group.rule.target.parameter.value[x]",
"short": "Parameter value - variable or literal",
"definition": "Parameter value - variable or literal.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
},
{
"code": "string"
},
{
"code": "boolean"
},
{
"code": "integer"
},
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.rule",
"path": "StructureMap.group.rule.rule",
"short": "Rules contained in this rule",
"definition": "Rules contained in this rule.",
"min": 0,
"max": "*",
"contentReference": "#StructureMap.group.rule",
"isSummary": true
},
{
"id": "StructureMap.group.rule.dependent",
"path": "StructureMap.group.rule.dependent",
"short": "Which other rules to apply in the context of this rule",
"definition": "Which other rules to apply in the context of this rule.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.dependent.name",
"path": "StructureMap.group.rule.dependent.name",
"short": "Name of a rule or group to apply",
"definition": "Name of a rule or group to apply.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.dependent.variable",
"path": "StructureMap.group.rule.dependent.variable",
"short": "Variable to pass to the rule or group",
"definition": "Variable to pass to the rule or group.",
"min": 1,
"max": "*",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "StructureMap.group.rule.documentation",
"path": "StructureMap.group.rule.documentation",
"short": "Documentation for this instance of data",
"definition": "Documentation for this instance of data.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Subscription",
"resource": {
"resourceType": "StructureDefinition",
"id": "Subscription",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Subscription Σ DomainResource A server push subscription criteria
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension status ?!Σ 1..1 code requested | active | error | off
SubscriptionStatus (Required) contact Σ 0..* ContactPoint Contact details for source (e.g. troubleshooting)
end Σ 0..1 instant When to automatically delete the subscription reason Σ 1..1 string Description of why this subscription was created criteria Σ 1..1 string Rule for server push criteria error Σ 0..1 string Latest error note channel Σ 1..1 BackboneElement The channel on which to report matches to the criteria type Σ 1..1 code rest-hook | websocket | email | sms | message
SubscriptionChannelType (Required) endpoint Σ 0..1 uri Where the channel points to payload Σ 0..1 string Mimetype to send, or omit for no payload header Σ 0..* string Usage depends on the channel type
tag Σ 0..* Coding A tag to add to matching resources
SubscriptionTag (Example)
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 3
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Subscription",
"name": "Subscription",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Subscription Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Subscription",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Subscription",
"path": "Subscription",
"short": "A server push subscription criteria",
"definition": "The subscription resource is used to define a push based subscription from a server to another system. Once a subscription is registered with the server, the server checks every resource that is created or updated, and if the resource matches the given criteria, it sends a message on the defined \"channel\" so that another system is able to take an appropriate action.",
"alias": [
"WebHook",
"Hook",
"Routing Rule"
],
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "infrastructure.exchange"
}
]
},
{
"id": "Subscription.id",
"path": "Subscription.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Subscription.meta",
"path": "Subscription.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Subscription.implicitRules",
"path": "Subscription.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Subscription.language",
"path": "Subscription.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Subscription.text",
"path": "Subscription.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Subscription.contained",
"path": "Subscription.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Subscription.extension",
"path": "Subscription.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Subscription.modifierExtension",
"path": "Subscription.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Subscription.status",
"path": "Subscription.status",
"short": "requested | active | error | off",
"definition": "The status of the subscription, which marks the server state for managing the subscription.",
"comment": "A client can only submit subscription resources in the requested or off state. Only the server can move a subscription from requested to active, and then to error. Either the server or the client can turn a subscription off.\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubscriptionStatus"
}
],
"strength": "required",
"description": "The status of a subscription.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/subscription-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Subscription.contact",
"path": "Subscription.contact",
"short": "Contact details for source (e.g. troubleshooting)",
"definition": "Contact details for a human to contact about the subscription. The primary use of this for system administrator troubleshooting.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Subscription.end",
"path": "Subscription.end",
"short": "When to automatically delete the subscription",
"definition": "The time for the server to turn the subscription off.",
"comment": "The server is permitted to deviate from this time, but should observe it.",
"min": 0,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Subscription.reason",
"path": "Subscription.reason",
"short": "Description of why this subscription was created",
"definition": "A description of why this subscription is defined.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Subscription.criteria",
"path": "Subscription.criteria",
"short": "Rule for server push criteria",
"definition": "The rules that the server should use to determine when to generate notifications for this subscription.",
"comment": "The rules are a search criteria (without the [base] part). Like Bundle.entry.request.url, it has no leading \"/\".",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Subscription.error",
"path": "Subscription.error",
"short": "Latest error note",
"definition": "A record of the last error that occurred when the server processed a notification.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Subscription.channel",
"path": "Subscription.channel",
"short": "The channel on which to report matches to the criteria",
"definition": "Details where to send notifications when resources are received that meet the criteria.",
"min": 1,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true
},
{
"id": "Subscription.channel.id",
"path": "Subscription.channel.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Subscription.channel.extension",
"path": "Subscription.channel.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Subscription.channel.modifierExtension",
"path": "Subscription.channel.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Subscription.channel.type",
"path": "Subscription.channel.type",
"short": "rest-hook | websocket | email | sms | message",
"definition": "The type of channel to send notifications on.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubscriptionChannelType"
}
],
"strength": "required",
"description": "The type of method used to execute a subscription.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/subscription-channel-type"
}
}
},
{
"id": "Subscription.channel.endpoint",
"path": "Subscription.channel.endpoint",
"short": "Where the channel points to",
"definition": "The uri that describes the actual end-point to send messages to.",
"comment": "For rest-hook, and websocket, the end-point must be an http: or https: URL; for email, a mailto: url, for sms, a tel: url, and for message the endpoint can be in any form of url the server understands (usually, http: or mllp:). The URI is allowed to be relative; in which case, it is relative to the server end-point (since their may be more than one, clients should avoid using relative URIs).",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true
},
{
"id": "Subscription.channel.payload",
"path": "Subscription.channel.payload",
"short": "Mimetype to send, or omit for no payload",
"definition": "The mime type to send the payload in - either application/fhir+xml, or application/fhir+json. If the payload is not present, then there is no payload in the notification, just a notification.",
"comment": "Sending the payload has obvious security implications. The server is responsible for ensuring that the content is appropriately secured.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Subscription.channel.header",
"path": "Subscription.channel.header",
"short": "Usage depends on the channel type",
"definition": "Additional headers / information to send as part of the notification.",
"comment": "Exactly what these mean depend on the channel type. They can convey additional information to the recipient and/or meet security requirements; for example, support of multiple headers in the outgoing notifications for rest-hook type subscriptions.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Subscription.tag",
"path": "Subscription.tag",
"short": "A tag to add to matching resources",
"definition": "A tag to add to any resource that matches the criteria, after the subscription is processed.",
"comment": "So that other systems can tell which resources have been the subject of a notification.",
"min": 0,
"max": "*",
"type": [
{
"code": "Coding"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubscriptionTag"
}
],
"strength": "example",
"description": "Tags to put on a resource after subscriptions have been sent.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/subscription-tag"
}
}
}
]
},
"differential": {
"element": [
{
"id": "Subscription",
"path": "Subscription",
"short": "A server push subscription criteria",
"definition": "The subscription resource is used to define a push based subscription from a server to another system. Once a subscription is registered with the server, the server checks every resource that is created or updated, and if the resource matches the given criteria, it sends a message on the defined \"channel\" so that another system is able to take an appropriate action.",
"alias": [
"WebHook",
"Hook",
"Routing Rule"
],
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "infrastructure.exchange"
}
]
},
{
"id": "Subscription.status",
"path": "Subscription.status",
"short": "requested | active | error | off",
"definition": "The status of the subscription, which marks the server state for managing the subscription.",
"comment": "A client can only submit subscription resources in the requested or off state. Only the server can move a subscription from requested to active, and then to error. Either the server or the client can turn a subscription off.\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubscriptionStatus"
}
],
"strength": "required",
"description": "The status of a subscription.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/subscription-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Subscription.contact",
"path": "Subscription.contact",
"short": "Contact details for source (e.g. troubleshooting)",
"definition": "Contact details for a human to contact about the subscription. The primary use of this for system administrator troubleshooting.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactPoint"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Subscription.end",
"path": "Subscription.end",
"short": "When to automatically delete the subscription",
"definition": "The time for the server to turn the subscription off.",
"comment": "The server is permitted to deviate from this time, but should observe it.",
"min": 0,
"max": "1",
"type": [
{
"code": "instant"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Subscription.reason",
"path": "Subscription.reason",
"short": "Description of why this subscription was created",
"definition": "A description of why this subscription is defined.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Subscription.criteria",
"path": "Subscription.criteria",
"short": "Rule for server push criteria",
"definition": "The rules that the server should use to determine when to generate notifications for this subscription.",
"comment": "The rules are a search criteria (without the [base] part). Like Bundle.entry.request.url, it has no leading \"/\".",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Subscription.error",
"path": "Subscription.error",
"short": "Latest error note",
"definition": "A record of the last error that occurred when the server processed a notification.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Subscription.channel",
"path": "Subscription.channel",
"short": "The channel on which to report matches to the criteria",
"definition": "Details where to send notifications when resources are received that meet the criteria.",
"min": 1,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true
},
{
"id": "Subscription.channel.type",
"path": "Subscription.channel.type",
"short": "rest-hook | websocket | email | sms | message",
"definition": "The type of channel to send notifications on.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubscriptionChannelType"
}
],
"strength": "required",
"description": "The type of method used to execute a subscription.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/subscription-channel-type"
}
}
},
{
"id": "Subscription.channel.endpoint",
"path": "Subscription.channel.endpoint",
"short": "Where the channel points to",
"definition": "The uri that describes the actual end-point to send messages to.",
"comment": "For rest-hook, and websocket, the end-point must be an http: or https: URL; for email, a mailto: url, for sms, a tel: url, and for message the endpoint can be in any form of url the server understands (usually, http: or mllp:). The URI is allowed to be relative; in which case, it is relative to the server end-point (since their may be more than one, clients should avoid using relative URIs).",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true
},
{
"id": "Subscription.channel.payload",
"path": "Subscription.channel.payload",
"short": "Mimetype to send, or omit for no payload",
"definition": "The mime type to send the payload in - either application/fhir+xml, or application/fhir+json. If the payload is not present, then there is no payload in the notification, just a notification.",
"comment": "Sending the payload has obvious security implications. The server is responsible for ensuring that the content is appropriately secured.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Subscription.channel.header",
"path": "Subscription.channel.header",
"short": "Usage depends on the channel type",
"definition": "Additional headers / information to send as part of the notification.",
"comment": "Exactly what these mean depend on the channel type. They can convey additional information to the recipient and/or meet security requirements; for example, support of multiple headers in the outgoing notifications for rest-hook type subscriptions.",
"min": 0,
"max": "*",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "Subscription.tag",
"path": "Subscription.tag",
"short": "A tag to add to matching resources",
"definition": "A tag to add to any resource that matches the criteria, after the subscription is processed.",
"comment": "So that other systems can tell which resources have been the subject of a notification.",
"min": 0,
"max": "*",
"type": [
{
"code": "Coding"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubscriptionTag"
}
],
"strength": "example",
"description": "Tags to put on a resource after subscriptions have been sent.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/subscription-tag"
}
}
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Substance",
"resource": {
"resourceType": "StructureDefinition",
"id": "Substance",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Substance DomainResource A homogeneous material with a definite composition
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..* Identifier Unique identifier
status Σ 0..1 code active | inactive | entered-in-error
FHIRSubstanceStatus (Required) category Σ 0..* CodeableConcept What class/type of substance this is
Substance Category Codes (Extensible)
code Σ 1..1 CodeableConcept What substance this is
Substance Code (Example) description Σ 0..1 string Textual description of the substance, comments instance Σ 0..* BackboneElement If this describes a specific package/container of the substance
identifier Σ 0..1 Identifier Identifier of the package/container expiry Σ 0..1 dateTime When no longer valid to use quantity Σ 0..1 SimpleQuantity Amount of substance in the package ingredient Σ 0..* BackboneElement Composition information about the substance
quantity Σ 0..1 Ratio Optional amount (concentration) substance[x] Σ 1..1 A component of the substance
Substance Code (Example) substanceCodeableConcept CodeableConcept substanceReference Reference(Substance)
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "oo"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Substance",
"name": "Substance",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Orders and Observations)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/orders/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Substance Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "orim",
"uri": "http://hl7.org/orim",
"name": "Ontological RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Substance",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Substance",
"path": "Substance",
"short": "A homogeneous material with a definite composition",
"definition": "A homogeneous material with a definite composition.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "Material"
},
{
"identity": "orim",
"map": "fhir:Substance rdfs:subClassOf rim:Entity, [ a owl:Restriction; owl:onProperty rim:Act.classCode; owl:allValuesFrom cs:EntityClass\\#MAT ]."
},
{
"identity": "w5",
"map": "administrative.entity"
}
]
},
{
"id": "Substance.id",
"path": "Substance.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Substance.meta",
"path": "Substance.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Substance.implicitRules",
"path": "Substance.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Substance.language",
"path": "Substance.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Substance.text",
"path": "Substance.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Substance.contained",
"path": "Substance.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Substance.extension",
"path": "Substance.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Substance.modifierExtension",
"path": "Substance.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Substance.identifier",
"path": "Substance.identifier",
"short": "Unique identifier",
"definition": "Unique identifier for the substance.",
"comment": "This identifier is associated with the kind of substance in contrast to the Substance.instance.identifier which is associated with the package/container.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Substance.status",
"path": "Substance.status",
"short": "active | inactive | entered-in-error",
"definition": "A code to indicate if the substance is actively used.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FHIRSubstanceStatus"
}
],
"strength": "required",
"description": "A code to indicate if the substance is actively used",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/substance-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Substance.category",
"path": "Substance.category",
"short": "What class/type of substance this is",
"definition": "A code that classifies the general type of substance. This is used for searching, sorting and display purposes.",
"comment": "The level of granularity is defined by the category concepts in the value set. More fine-grained filtering can be performed using the metadata and/or terminology hierarchy in Substance.code.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubstanceCategory"
}
],
"strength": "extensible",
"description": "Category or classification of substance",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/substance-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Substance.code",
"path": "Substance.code",
"short": "What substance this is",
"definition": "A code (or set of codes) that identify this substance.",
"comment": "This could be a reference to an externally defined code. It could also be a locally assigned code (e.g. a formulary), optionally with translations to the standard drug codes.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubstanceCode"
}
],
"strength": "example",
"description": "Substance codes",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/substance-code"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
},
{
"identity": "orim",
"map": "fhir:Substance.code rdfs:subPropertyOf rim:Entity.code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Substance.description",
"path": "Substance.description",
"short": "Textual description of the substance, comments",
"definition": "A description of the substance - its appearance, handling requirements, and other usage notes.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player.desc"
}
]
},
{
"id": "Substance.instance",
"path": "Substance.instance",
"short": "If this describes a specific package/container of the substance",
"definition": "Substance may be used to describe a kind of substance, or a specific package/container of the substance: an instance.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"meaningWhenMissing": "If this element is not present, then the substance resource describes a kind of substance",
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player.determinerCode"
}
]
},
{
"id": "Substance.instance.id",
"path": "Substance.instance.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Substance.instance.extension",
"path": "Substance.instance.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Substance.instance.modifierExtension",
"path": "Substance.instance.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Substance.instance.identifier",
"path": "Substance.instance.identifier",
"short": "Identifier of the package/container",
"definition": "Identifier associated with the package/container (usually a label affixed directly).",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "Substance.instance.expiry",
"path": "Substance.instance.expiry",
"short": "When no longer valid to use",
"definition": "When the substance is no longer valid to use. For some substances, a single arbitrary date is used for expiry.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".expiryTime"
}
]
},
{
"id": "Substance.instance.quantity",
"path": "Substance.instance.quantity",
"short": "Amount of substance in the package",
"definition": "The amount of the substance.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player.quantity"
}
]
},
{
"id": "Substance.ingredient",
"path": "Substance.ingredient",
"short": "Composition information about the substance",
"definition": "A substance can be composed of other substances.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player.scopesRole[classCode=INGR]"
}
]
},
{
"id": "Substance.ingredient.id",
"path": "Substance.ingredient.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Substance.ingredient.extension",
"path": "Substance.ingredient.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Substance.ingredient.modifierExtension",
"path": "Substance.ingredient.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Substance.ingredient.quantity",
"path": "Substance.ingredient.quantity",
"short": "Optional amount (concentration)",
"definition": "The amount of the ingredient in the substance - a concentration ratio.",
"min": 0,
"max": "1",
"type": [
{
"code": "Ratio"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "Substance.ingredient.substance[x]",
"path": "Substance.ingredient.substance[x]",
"short": "A component of the substance",
"definition": "Another substance that is a component of this substance.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubstanceIngredient"
}
],
"strength": "example",
"description": "Substance Ingredient codes",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/substance-code"
}
},
"mapping": [
{
"identity": "rim",
"map": ".player"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Substance",
"path": "Substance",
"short": "A homogeneous material with a definite composition",
"definition": "A homogeneous material with a definite composition.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "Material"
},
{
"identity": "orim",
"map": "fhir:Substance rdfs:subClassOf rim:Entity, [ a owl:Restriction; owl:onProperty rim:Act.classCode; owl:allValuesFrom cs:EntityClass\\#MAT ]."
},
{
"identity": "w5",
"map": "administrative.entity"
}
]
},
{
"id": "Substance.identifier",
"path": "Substance.identifier",
"short": "Unique identifier",
"definition": "Unique identifier for the substance.",
"comment": "This identifier is associated with the kind of substance in contrast to the Substance.instance.identifier which is associated with the package/container.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Substance.status",
"path": "Substance.status",
"short": "active | inactive | entered-in-error",
"definition": "A code to indicate if the substance is actively used.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FHIRSubstanceStatus"
}
],
"strength": "required",
"description": "A code to indicate if the substance is actively used",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/substance-status"
}
},
"mapping": [
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Substance.category",
"path": "Substance.category",
"short": "What class/type of substance this is",
"definition": "A code that classifies the general type of substance. This is used for searching, sorting and display purposes.",
"comment": "The level of granularity is defined by the category concepts in the value set. More fine-grained filtering can be performed using the metadata and/or terminology hierarchy in Substance.code.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubstanceCategory"
}
],
"strength": "extensible",
"description": "Category or classification of substance",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/substance-category"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Substance.code",
"path": "Substance.code",
"short": "What substance this is",
"definition": "A code (or set of codes) that identify this substance.",
"comment": "This could be a reference to an externally defined code. It could also be a locally assigned code (e.g. a formulary), optionally with translations to the standard drug codes.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubstanceCode"
}
],
"strength": "example",
"description": "Substance codes",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/substance-code"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
},
{
"identity": "orim",
"map": "fhir:Substance.code rdfs:subPropertyOf rim:Entity.code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Substance.description",
"path": "Substance.description",
"short": "Textual description of the substance, comments",
"definition": "A description of the substance - its appearance, handling requirements, and other usage notes.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player.desc"
}
]
},
{
"id": "Substance.instance",
"path": "Substance.instance",
"short": "If this describes a specific package/container of the substance",
"definition": "Substance may be used to describe a kind of substance, or a specific package/container of the substance: an instance.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"meaningWhenMissing": "If this element is not present, then the substance resource describes a kind of substance",
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player.determinerCode"
}
]
},
{
"id": "Substance.instance.identifier",
"path": "Substance.instance.identifier",
"short": "Identifier of the package/container",
"definition": "Identifier associated with the package/container (usually a label affixed directly).",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "Substance.instance.expiry",
"path": "Substance.instance.expiry",
"short": "When no longer valid to use",
"definition": "When the substance is no longer valid to use. For some substances, a single arbitrary date is used for expiry.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".expiryTime"
}
]
},
{
"id": "Substance.instance.quantity",
"path": "Substance.instance.quantity",
"short": "Amount of substance in the package",
"definition": "The amount of the substance.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player.quantity"
}
]
},
{
"id": "Substance.ingredient",
"path": "Substance.ingredient",
"short": "Composition information about the substance",
"definition": "A substance can be composed of other substances.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".player.scopesRole[classCode=INGR]"
}
]
},
{
"id": "Substance.ingredient.quantity",
"path": "Substance.ingredient.quantity",
"short": "Optional amount (concentration)",
"definition": "The amount of the ingredient in the substance - a concentration ratio.",
"min": 0,
"max": "1",
"type": [
{
"code": "Ratio"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "Substance.ingredient.substance[x]",
"path": "Substance.ingredient.substance[x]",
"short": "A component of the substance",
"definition": "Another substance that is a component of this substance.",
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SubstanceIngredient"
}
],
"strength": "example",
"description": "Substance Ingredient codes",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/substance-code"
}
},
"mapping": [
{
"identity": "rim",
"map": ".player"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/SupplyDelivery",
"resource": {
"resourceType": "StructureDefinition",
"id": "SupplyDelivery",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints SupplyDelivery DomainResource Delivery of bulk Supplies
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..1 Identifier External identifier basedOn Σ 0..* Reference(SupplyRequest) Fulfills plan, proposal or order
partOf Σ 0..* Reference(SupplyDelivery | Contract) Part of referenced event
status ?!Σ 0..1 code in-progress | completed | abandoned | entered-in-error
SupplyDeliveryStatus (Required) patient 0..1 Reference(Patient) Patient for whom the item is supplied type 0..1 CodeableConcept Category of dispense event
Supply Item Type (Required) suppliedItem 0..1 BackboneElement The item that is delivered or supplied quantity 0..1 SimpleQuantity Amount dispensed item[x] 0..1 Medication, Substance, or Device supplied
SNOMED CT Supply Item (Example) itemCodeableConcept CodeableConcept itemReference Reference(Medication | Substance | Device) occurrence[x] Σ 0..1 When event occurred occurrenceDateTime dateTime occurrencePeriod Period occurrenceTiming Timing supplier 0..1 Reference(Practitioner | Organization) Dispenser destination 0..1 Reference(Location) Where the Supply was sent receiver 0..* Reference(Practitioner) Who collected the Supply
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 1
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "oo"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/SupplyDelivery",
"name": "SupplyDelivery",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Orders and Observations)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/orders/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for SupplyDelivery Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "SupplyDelivery",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "SupplyDelivery",
"path": "SupplyDelivery",
"short": "Delivery of bulk Supplies",
"definition": "Record of delivery of what is supplied.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "rim",
"map": "Supply[moodCode=RQO]"
},
{
"identity": "w5",
"map": "workflow.order"
}
]
},
{
"id": "SupplyDelivery.id",
"path": "SupplyDelivery.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "SupplyDelivery.meta",
"path": "SupplyDelivery.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "SupplyDelivery.implicitRules",
"path": "SupplyDelivery.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "SupplyDelivery.language",
"path": "SupplyDelivery.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "SupplyDelivery.text",
"path": "SupplyDelivery.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "SupplyDelivery.contained",
"path": "SupplyDelivery.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SupplyDelivery.extension",
"path": "SupplyDelivery.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SupplyDelivery.modifierExtension",
"path": "SupplyDelivery.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SupplyDelivery.identifier",
"path": "SupplyDelivery.identifier",
"short": "External identifier",
"definition": "Identifier assigned by the dispensing facility when the item(s) is dispensed.",
"comment": "This is assigned by the dispenser, and used to refer to this order in other external standards.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "SupplyDelivery.basedOn",
"path": "SupplyDelivery.basedOn",
"short": "Fulfills plan, proposal or order",
"definition": "A plan, proposal or order that is fulfilled in whole or in part by this event.",
"requirements": "Allows tracing of authorization for the event and tracking whether proposals/recommendations were acted upon.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/SupplyRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.basedOn"
},
{
"identity": "v2",
"map": "ORC in proximity to EVN segment"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target"
}
]
},
{
"id": "SupplyDelivery.partOf",
"path": "SupplyDelivery.partOf",
"short": "Part of referenced event",
"definition": "A larger event of which this particular event is a component or step.",
"comment": "Not to be used to link an event to an Encounter - use Event.context for that.\r\r[The allowed reference resources may be adjusted as appropriate for the event resource].",
"requirements": "E.g. Drug administration as part of a procedure, procedure as part of observation, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/SupplyDelivery"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Contract"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.partOf"
},
{
"identity": "v2",
"map": "Varies by domain"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[moodCode=EVN]"
}
]
},
{
"id": "SupplyDelivery.status",
"path": "SupplyDelivery.status",
"short": "in-progress | completed | abandoned | entered-in-error",
"definition": "A code specifying the state of the dispense event.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyDeliveryStatus"
}
],
"strength": "required",
"description": "Status of the supply delivery.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplydelivery-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "rim",
"map": ".statusCode, also existence of fulfillment events"
}
]
},
{
"id": "SupplyDelivery.patient",
"path": "SupplyDelivery.patient",
"short": "Patient for whom the item is supplied",
"definition": "A link to a resource representing the person whom the delivered item is for.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.subject.reference(Patient)"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
}
]
},
{
"id": "SupplyDelivery.type",
"path": "SupplyDelivery.type",
"short": "Category of dispense event",
"definition": "Indicates the type of dispensing event that is performed. Examples include: Trial Fill, Completion of Trial, Partial Fill, Emergency Fill, Samples, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyDeliveryType"
}
],
"strength": "required",
"description": "The type of supply dispense.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplydelivery-type"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.code"
},
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "SupplyDelivery.suppliedItem",
"path": "SupplyDelivery.suppliedItem",
"short": "The item that is delivered or supplied",
"definition": "The item that is being delivered or has been supplied.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=PRD].role"
}
]
},
{
"id": "SupplyDelivery.suppliedItem.id",
"path": "SupplyDelivery.suppliedItem.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "SupplyDelivery.suppliedItem.extension",
"path": "SupplyDelivery.suppliedItem.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "SupplyDelivery.suppliedItem.modifierExtension",
"path": "SupplyDelivery.suppliedItem.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SupplyDelivery.suppliedItem.quantity",
"path": "SupplyDelivery.suppliedItem.quantity",
"short": "Amount dispensed",
"definition": "The amount of supply that has been dispensed. Includes unit of measure.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "SupplyDelivery.suppliedItem.item[x]",
"path": "SupplyDelivery.suppliedItem.item[x]",
"short": "Medication, Substance, or Device supplied",
"definition": "Identifies the medication, substance or device being dispensed. This is either a link to a resource representing the details of the item or a code that identifies the item from a known list.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyDeliveryItem"
}
],
"strength": "example",
"description": "The item that was delivered.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supply-item"
}
},
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=PRD].role"
}
]
},
{
"id": "SupplyDelivery.occurrence[x]",
"path": "SupplyDelivery.occurrence[x]",
"short": "When event occurred",
"definition": "The date or time(s) the activity occurred.",
"comment": "[The list of types may be constrained as appropriate for the type of event].",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
},
{
"code": "Timing"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence[x]"
},
{
"identity": "v2",
"map": "Varies by domain"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "SupplyDelivery.supplier",
"path": "SupplyDelivery.supplier",
"short": "Dispenser",
"definition": "The individual responsible for dispensing the medication, supplier or device.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.performer"
},
{
"identity": "rim",
"map": ".participation[typeCode=PFM].role"
}
]
},
{
"id": "SupplyDelivery.destination",
"path": "SupplyDelivery.destination",
"short": "Where the Supply was sent",
"definition": "Identification of the facility/location where the Supply was shipped to, as part of the dispense event.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=DST].role"
}
]
},
{
"id": "SupplyDelivery.receiver",
"path": "SupplyDelivery.receiver",
"short": "Who collected the Supply",
"definition": "Identifies the person who picked up the Supply.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=RCV].role"
}
]
}
]
},
"differential": {
"element": [
{
"id": "SupplyDelivery",
"path": "SupplyDelivery",
"short": "Delivery of bulk Supplies",
"definition": "Record of delivery of what is supplied.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Event"
},
{
"identity": "rim",
"map": "Supply[moodCode=RQO]"
},
{
"identity": "w5",
"map": "workflow.order"
}
]
},
{
"id": "SupplyDelivery.identifier",
"path": "SupplyDelivery.identifier",
"short": "External identifier",
"definition": "Identifier assigned by the dispensing facility when the item(s) is dispensed.",
"comment": "This is assigned by the dispenser, and used to refer to this order in other external standards.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.identifier"
},
{
"identity": "rim",
"map": ".id"
}
]
},
{
"id": "SupplyDelivery.basedOn",
"path": "SupplyDelivery.basedOn",
"short": "Fulfills plan, proposal or order",
"definition": "A plan, proposal or order that is fulfilled in whole or in part by this event.",
"requirements": "Allows tracing of authorization for the event and tracking whether proposals/recommendations were acted upon.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/SupplyRequest"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.basedOn"
},
{
"identity": "v2",
"map": "ORC in proximity to EVN segment"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target"
}
]
},
{
"id": "SupplyDelivery.partOf",
"path": "SupplyDelivery.partOf",
"short": "Part of referenced event",
"definition": "A larger event of which this particular event is a component or step.",
"comment": "Not to be used to link an event to an Encounter - use Event.context for that.\r\r[The allowed reference resources may be adjusted as appropriate for the event resource].",
"requirements": "E.g. Drug administration as part of a procedure, procedure as part of observation, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/SupplyDelivery"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Contract"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.partOf"
},
{
"identity": "v2",
"map": "Varies by domain"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[moodCode=EVN]"
}
]
},
{
"id": "SupplyDelivery.status",
"path": "SupplyDelivery.status",
"short": "in-progress | completed | abandoned | entered-in-error",
"definition": "A code specifying the state of the dispense event.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyDeliveryStatus"
}
],
"strength": "required",
"description": "Status of the supply delivery.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplydelivery-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.status"
},
{
"identity": "rim",
"map": ".statusCode, also existence of fulfillment events"
}
]
},
{
"id": "SupplyDelivery.patient",
"path": "SupplyDelivery.patient",
"short": "Patient for whom the item is supplied",
"definition": "A link to a resource representing the person whom the delivered item is for.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.subject.reference(Patient)"
},
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
}
]
},
{
"id": "SupplyDelivery.type",
"path": "SupplyDelivery.type",
"short": "Category of dispense event",
"definition": "Indicates the type of dispensing event that is performed. Examples include: Trial Fill, Completion of Trial, Partial Fill, Emergency Fill, Samples, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyDeliveryType"
}
],
"strength": "required",
"description": "The type of supply dispense.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplydelivery-type"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.code"
},
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "SupplyDelivery.suppliedItem",
"path": "SupplyDelivery.suppliedItem",
"short": "The item that is delivered or supplied",
"definition": "The item that is being delivered or has been supplied.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=PRD].role"
}
]
},
{
"id": "SupplyDelivery.suppliedItem.quantity",
"path": "SupplyDelivery.suppliedItem.quantity",
"short": "Amount dispensed",
"definition": "The amount of supply that has been dispensed. Includes unit of measure.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
],
"mapping": [
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "SupplyDelivery.suppliedItem.item[x]",
"path": "SupplyDelivery.suppliedItem.item[x]",
"short": "Medication, Substance, or Device supplied",
"definition": "Identifies the medication, substance or device being dispensed. This is either a link to a resource representing the details of the item or a code that identifies the item from a known list.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyDeliveryItem"
}
],
"strength": "example",
"description": "The item that was delivered.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supply-item"
}
},
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=PRD].role"
}
]
},
{
"id": "SupplyDelivery.occurrence[x]",
"path": "SupplyDelivery.occurrence[x]",
"short": "When event occurred",
"definition": "The date or time(s) the activity occurred.",
"comment": "[The list of types may be constrained as appropriate for the type of event].",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
},
{
"code": "Timing"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence[x]"
},
{
"identity": "v2",
"map": "Varies by domain"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "SupplyDelivery.supplier",
"path": "SupplyDelivery.supplier",
"short": "Dispenser",
"definition": "The individual responsible for dispensing the medication, supplier or device.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Event.performer"
},
{
"identity": "rim",
"map": ".participation[typeCode=PFM].role"
}
]
},
{
"id": "SupplyDelivery.destination",
"path": "SupplyDelivery.destination",
"short": "Where the Supply was sent",
"definition": "Identification of the facility/location where the Supply was shipped to, as part of the dispense event.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=DST].role"
}
]
},
{
"id": "SupplyDelivery.receiver",
"path": "SupplyDelivery.receiver",
"short": "Who collected the Supply",
"definition": "Identifies the person who picked up the Supply.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=RCV].role"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/SupplyRequest",
"resource": {
"resourceType": "StructureDefinition",
"id": "SupplyRequest",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints SupplyRequest DomainResource Request for a medication, substance or device
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..1 Identifier Unique identifier status ?!Σ 0..1 code draft | active | suspended +
SupplyRequestStatus (Required) category Σ 0..1 CodeableConcept The kind of supply (central, non-stock, etc.)
Supply Type (Example) priority Σ 0..1 code routine | urgent | asap | stat
RequestPriority (Required) orderedItem Σ 0..1 BackboneElement The item being requested quantity Σ 1..1 Quantity The requested amount of the item indicated item[x] Σ 0..1 Medication, Substance, or Device requested to be supplied
SNOMED CT Supply Item (Example) itemCodeableConcept CodeableConcept itemReference Reference(Medication | Substance | Device) occurrence[x] Σ 0..1 When the request should be fulfilled occurrenceDateTime dateTime occurrencePeriod Period occurrenceTiming Timing authoredOn Σ 0..1 dateTime When the request was made requester Σ 0..1 BackboneElement Who/what is requesting service agent Σ 1..1 Reference(Practitioner | Organization | Patient | RelatedPerson | Device) Individual making the request onBehalfOf 0..1 Reference(Organization) Organization agent is acting for supplier Σ 0..* Reference(Organization) Who is intended to fulfill the request
reason[x] 0..1 Why the supply item was requested
SupplyRequestReason (Example) reasonCodeableConcept CodeableConcept reasonReference Reference(Any) deliverFrom 0..1 Reference(Organization | Location) The origin of the supply deliverTo 0..1 Reference(Organization | Location | Patient) The destination of the supply
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 1
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "oo"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/SupplyRequest",
"name": "SupplyRequest",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Orders and Observations)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/orders/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for SupplyRequest Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "SupplyRequest",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "SupplyRequest",
"path": "SupplyRequest",
"short": "Request for a medication, substance or device",
"definition": "A record of a request for a medication, substance or device used in the healthcare setting.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "v2",
"map": "ORC"
},
{
"identity": "rim",
"map": "Act[moodCode<=INT]"
},
{
"identity": "w5",
"map": "workflow.order"
}
]
},
{
"id": "SupplyRequest.id",
"path": "SupplyRequest.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "SupplyRequest.meta",
"path": "SupplyRequest.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "SupplyRequest.implicitRules",
"path": "SupplyRequest.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "SupplyRequest.language",
"path": "SupplyRequest.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "SupplyRequest.text",
"path": "SupplyRequest.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "SupplyRequest.contained",
"path": "SupplyRequest.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SupplyRequest.extension",
"path": "SupplyRequest.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SupplyRequest.modifierExtension",
"path": "SupplyRequest.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SupplyRequest.identifier",
"path": "SupplyRequest.identifier",
"short": "Unique identifier",
"definition": "Unique identifier for this supply request.",
"comment": "This is assigned by the requester, and used to refer to this order in other external standards.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "v2",
"map": "ORC.2, ORC.3"
},
{
"identity": "rim",
"map": ".identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "SupplyRequest.status",
"path": "SupplyRequest.status",
"short": "draft | active | suspended +",
"definition": "Status of the supply request.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyRequestStatus"
}
],
"strength": "required",
"description": "Status of the supply request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplyrequest-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "v2",
"map": "ORC.5"
},
{
"identity": "rim",
"map": ".status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "SupplyRequest.category",
"path": "SupplyRequest.category",
"short": "The kind of supply (central, non-stock, etc.)",
"definition": "Category of supply, e.g. central, non-stock, etc. This is used to support work flows associated with the supply process.",
"alias": [
"kind"
],
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyRequestKind"
}
],
"strength": "example",
"description": "Category of supply request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplyrequest-kind"
}
},
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "SupplyRequest.priority",
"path": "SupplyRequest.priority",
"short": "routine | urgent | asap | stat",
"definition": "Indicates how quickly this SupplyRequest should be addressed with respect to other requests.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "If missing, this task should be performed with normal priority",
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RequestPriority"
}
],
"strength": "required",
"description": "Identifies the level of importance to be assigned to actioning the request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-priority"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.priority"
},
{
"identity": "v2",
"map": "TQ1.9"
},
{
"identity": "rim",
"map": ".priorityCode"
},
{
"identity": "w5",
"map": "grade"
}
]
},
{
"id": "SupplyRequest.orderedItem",
"path": "SupplyRequest.orderedItem",
"short": "The item being requested",
"definition": "The item being requested.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.code"
},
{
"identity": "v2",
"map": "Varies by domain"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "SupplyRequest.orderedItem.id",
"path": "SupplyRequest.orderedItem.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "SupplyRequest.orderedItem.extension",
"path": "SupplyRequest.orderedItem.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "SupplyRequest.orderedItem.modifierExtension",
"path": "SupplyRequest.orderedItem.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SupplyRequest.orderedItem.quantity",
"path": "SupplyRequest.orderedItem.quantity",
"short": "The requested amount of the item indicated",
"definition": "The amount that is being ordered of the indicated item.",
"min": 1,
"max": "1",
"type": [
{
"code": "Quantity"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "SupplyRequest.orderedItem.item[x]",
"path": "SupplyRequest.orderedItem.item[x]",
"short": "Medication, Substance, or Device requested to be supplied",
"definition": "The item that is requested to be supplied. This is either a link to a resource representing the details of the item or a code that identifies the item from a known list.",
"comment": "Note that there's a difference between a prescription - an instruction to take a medication, along with a (sometimes) implicit supply, and an explicit request to supply, with no explicit instructions.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyRequestItem"
}
],
"strength": "example",
"description": "The item that was requested",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supply-item"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "SupplyRequest.occurrence[x]",
"path": "SupplyRequest.occurrence[x]",
"short": "When the request should be fulfilled",
"definition": "When the request should be fulfilled.",
"alias": [
"when",
"timing"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
},
{
"code": "Timing"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.occurrence.occurrenceTiming"
},
{
"identity": "v2",
"map": "Accompanying TQ1/TQ2 segments"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "SupplyRequest.authoredOn",
"path": "SupplyRequest.authoredOn",
"short": "When the request was made",
"definition": "When the request was made.",
"alias": [
"date",
"createdOn",
"signedOn"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "v2",
"map": "ORC.9"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "SupplyRequest.requester",
"path": "SupplyRequest.requester",
"short": "Who/what is requesting service",
"definition": "The individual who initiated the request and has responsibility for its activation.",
"alias": [
"author",
"source"
],
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester"
},
{
"identity": "v2",
"map": "ORC.12"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "SupplyRequest.requester.id",
"path": "SupplyRequest.requester.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "SupplyRequest.requester.extension",
"path": "SupplyRequest.requester.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "SupplyRequest.requester.modifierExtension",
"path": "SupplyRequest.requester.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "SupplyRequest.requester.agent",
"path": "SupplyRequest.requester.agent",
"short": "Individual making the request",
"definition": "The device, practitioner, etc. who initiated the request.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.agent"
},
{
"identity": "v2",
"map": "ORC.12"
},
{
"identity": "rim",
"map": ".player"
}
]
},
{
"id": "SupplyRequest.requester.onBehalfOf",
"path": "SupplyRequest.requester.onBehalfOf",
"short": "Organization agent is acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when authoring the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.onBehalfOf"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "SupplyRequest.supplier",
"path": "SupplyRequest.supplier",
"short": "Who is intended to fulfill the request",
"definition": "Who is intended to fulfill the request.",
"alias": [
"performer"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.performer"
},
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF].role[scoper.determinerCode=INSTANCE]"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "SupplyRequest.reason[x]",
"path": "SupplyRequest.reason[x]",
"short": "Why the supply item was requested",
"definition": "Why the supply item was requested.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyRequestReason"
}
],
"strength": "example",
"description": "Why the supply item was requested",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplyrequest-reason"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.reasonCode, Request.reasonReference"
},
{
"identity": "v2",
"map": "ORC.16"
},
{
"identity": "rim",
"map": ".reasonCode, .outboundRelationship[typeCode=RSON].target"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "SupplyRequest.deliverFrom",
"path": "SupplyRequest.deliverFrom",
"short": "The origin of the supply",
"definition": "Where the supply is expected to come from.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"mapping": [
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation"
}
]
},
{
"id": "SupplyRequest.deliverTo",
"path": "SupplyRequest.deliverTo",
"short": "The destination of the supply",
"definition": "Where the supply is destined to go.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"mapping": [
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation"
}
]
}
]
},
"differential": {
"element": [
{
"id": "SupplyRequest",
"path": "SupplyRequest",
"short": "Request for a medication, substance or device",
"definition": "A record of a request for a medication, substance or device used in the healthcare setting.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "v2",
"map": "ORC"
},
{
"identity": "rim",
"map": "Act[moodCode<=INT]"
},
{
"identity": "w5",
"map": "workflow.order"
}
]
},
{
"id": "SupplyRequest.identifier",
"path": "SupplyRequest.identifier",
"short": "Unique identifier",
"definition": "Unique identifier for this supply request.",
"comment": "This is assigned by the requester, and used to refer to this order in other external standards.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "v2",
"map": "ORC.2, ORC.3"
},
{
"identity": "rim",
"map": ".identifier"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "SupplyRequest.status",
"path": "SupplyRequest.status",
"short": "draft | active | suspended +",
"definition": "Status of the supply request.",
"comment": "This element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyRequestStatus"
}
],
"strength": "required",
"description": "Status of the supply request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplyrequest-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "v2",
"map": "ORC.5"
},
{
"identity": "rim",
"map": ".status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "SupplyRequest.category",
"path": "SupplyRequest.category",
"short": "The kind of supply (central, non-stock, etc.)",
"definition": "Category of supply, e.g. central, non-stock, etc. This is used to support work flows associated with the supply process.",
"alias": [
"kind"
],
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyRequestKind"
}
],
"strength": "example",
"description": "Category of supply request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplyrequest-kind"
}
},
"mapping": [
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "SupplyRequest.priority",
"path": "SupplyRequest.priority",
"short": "routine | urgent | asap | stat",
"definition": "Indicates how quickly this SupplyRequest should be addressed with respect to other requests.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "If missing, this task should be performed with normal priority",
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "RequestPriority"
}
],
"strength": "required",
"description": "Identifies the level of importance to be assigned to actioning the request",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-priority"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.priority"
},
{
"identity": "v2",
"map": "TQ1.9"
},
{
"identity": "rim",
"map": ".priorityCode"
},
{
"identity": "w5",
"map": "grade"
}
]
},
{
"id": "SupplyRequest.orderedItem",
"path": "SupplyRequest.orderedItem",
"short": "The item being requested",
"definition": "The item being requested.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.code"
},
{
"identity": "v2",
"map": "Varies by domain"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "SupplyRequest.orderedItem.quantity",
"path": "SupplyRequest.orderedItem.quantity",
"short": "The requested amount of the item indicated",
"definition": "The amount that is being ordered of the indicated item.",
"min": 1,
"max": "1",
"type": [
{
"code": "Quantity"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".quantity"
}
]
},
{
"id": "SupplyRequest.orderedItem.item[x]",
"path": "SupplyRequest.orderedItem.item[x]",
"short": "Medication, Substance, or Device requested to be supplied",
"definition": "The item that is requested to be supplied. This is either a link to a resource representing the details of the item or a code that identifies the item from a known list.",
"comment": "Note that there's a difference between a prescription - an instruction to take a medication, along with a (sometimes) implicit supply, and an explicit request to supply, with no explicit instructions.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Medication"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Substance"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyRequestItem"
}
],
"strength": "example",
"description": "The item that was requested",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supply-item"
}
},
"mapping": [
{
"identity": "rim",
"map": ".code"
}
]
},
{
"id": "SupplyRequest.occurrence[x]",
"path": "SupplyRequest.occurrence[x]",
"short": "When the request should be fulfilled",
"definition": "When the request should be fulfilled.",
"alias": [
"when",
"timing"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
},
{
"code": "Period"
},
{
"code": "Timing"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.occurrence.occurrenceTiming"
},
{
"identity": "v2",
"map": "Accompanying TQ1/TQ2 segments"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.planned"
}
]
},
{
"id": "SupplyRequest.authoredOn",
"path": "SupplyRequest.authoredOn",
"short": "When the request was made",
"definition": "When the request was made.",
"alias": [
"date",
"createdOn",
"signedOn"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "v2",
"map": "ORC.9"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "SupplyRequest.requester",
"path": "SupplyRequest.requester",
"short": "Who/what is requesting service",
"definition": "The individual who initiated the request and has responsibility for its activation.",
"alias": [
"author",
"source"
],
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester"
},
{
"identity": "v2",
"map": "ORC.12"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "SupplyRequest.requester.agent",
"path": "SupplyRequest.requester.agent",
"short": "Individual making the request",
"definition": "The device, practitioner, etc. who initiated the request.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.agent"
},
{
"identity": "v2",
"map": "ORC.12"
},
{
"identity": "rim",
"map": ".player"
}
]
},
{
"id": "SupplyRequest.requester.onBehalfOf",
"path": "SupplyRequest.requester.onBehalfOf",
"short": "Organization agent is acting for",
"definition": "The organization the device or practitioner was acting on behalf of.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when authoring the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.onBehalfOf"
},
{
"identity": "v2",
"map": "N/A"
},
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "SupplyRequest.supplier",
"path": "SupplyRequest.supplier",
"short": "Who is intended to fulfill the request",
"definition": "Who is intended to fulfill the request.",
"alias": [
"performer"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.performer"
},
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF].role[scoper.determinerCode=INSTANCE]"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "SupplyRequest.reason[x]",
"path": "SupplyRequest.reason[x]",
"short": "Why the supply item was requested",
"definition": "Why the supply item was requested.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "SupplyRequestReason"
}
],
"strength": "example",
"description": "Why the supply item was requested",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/supplyrequest-reason"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.reasonCode, Request.reasonReference"
},
{
"identity": "v2",
"map": "ORC.16"
},
{
"identity": "rim",
"map": ".reasonCode, .outboundRelationship[typeCode=RSON].target"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "SupplyRequest.deliverFrom",
"path": "SupplyRequest.deliverFrom",
"short": "The origin of the supply",
"definition": "Where the supply is expected to come from.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
}
],
"mapping": [
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation"
}
]
},
{
"id": "SupplyRequest.deliverTo",
"path": "SupplyRequest.deliverTo",
"short": "The destination of the supply",
"definition": "Where the supply is destined to go.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Location"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"mapping": [
{
"identity": "v2",
"map": "PRT"
},
{
"identity": "rim",
"map": ".participation"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/Task",
"resource": {
"resourceType": "StructureDefinition",
"id": "Task",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints Task I DomainResource A task to be performed
+ Last modified date must be greater than or equal to authored-on date.
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..* Identifier Task Instance Identifier
definition[x] Σ 0..1 Formal definition of task definitionUri uri definitionReference Reference(ActivityDefinition) basedOn Σ 0..* Reference(Any) Request fulfilled by this task
groupIdentifier Σ 0..1 Identifier Requisition or grouper id partOf Σ 0..* Reference(Task) Composite task
status Σ 1..1 code draft | requested | received | accepted | +
TaskStatus (Required) statusReason Σ 0..1 CodeableConcept Reason for current status businessStatus Σ 0..1 CodeableConcept E.g. "Specimen collected", "IV prepped" intent Σ 1..1 code proposal | plan | order +
RequestIntent (Required) priority 0..1 code normal | urgent | asap | stat
RequestPriority (Required) code Σ 0..1 CodeableConcept Task Type description Σ 0..1 string Human-readable explanation of task focus Σ 0..1 Reference(Any) What task is acting on for Σ 0..1 Reference(Any) Beneficiary of the Task context Σ 0..1 Reference(Encounter | EpisodeOfCare) Healthcare event during which this task originated executionPeriod Σ 0..1 Period Start and end time of execution authoredOn I 0..1 dateTime Task Creation Date lastModified ΣI 0..1 dateTime Task Last Modified Date requester Σ 0..1 BackboneElement Who is asking for task to be done agent Σ 1..1 Reference(Device | Organization | Patient | Practitioner | RelatedPerson) Individual asking for task onBehalfOf 0..1 Reference(Organization) Organization individual is acting for performerType 0..* CodeableConcept requester | dispatcher | scheduler | performer | monitor | manager | acquirer | reviewer
TaskPerformerType (Preferred)
owner Σ 0..1 Reference(Device | Organization | Patient | Practitioner | RelatedPerson) Responsible individual reason 0..1 CodeableConcept Why task is needed note 0..* Annotation Comments made about the task
relevantHistory 0..* Reference(Provenance) Key events in history of the Task
restriction 0..1 BackboneElement Constraints on fulfillment tasks repetitions 0..1 positiveInt How many times to repeat period 0..1 Period When fulfillment sought recipient 0..* Reference(Patient | Practitioner | RelatedPerson | Group | Organization) For whom is fulfillment sought?
input 0..* BackboneElement Information used to perform task
type 1..1 CodeableConcept Label for the input value[x] 1..1 * Content to use in performing the task output 0..* BackboneElement Information produced as part of task
type 1..1 CodeableConcept Label for output value[x] 1..1 * Result of output
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "oo"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/Task",
"name": "Task",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Orders and Observations)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/orders/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for Task Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "Task",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "Task",
"path": "Task",
"short": "A task to be performed",
"definition": "A task to be performed.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "inv-1",
"severity": "error",
"human": "Last modified date must be greater than or equal to authored-on date.",
"expression": "lastModified.exists().not() or authoredOn.exists().not() or lastModified >= authoredOn",
"xpath": "not(exists(f:lastModified/@value)) or not(exists(f:authoredOn/@value)) or f:lastModified/@value >= f:authoredOn/@value"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Request, Event"
},
{
"identity": "rim",
"map": "ControlAct[moodCode=INT]"
},
{
"identity": "w5",
"map": "workflow.order"
}
]
},
{
"id": "Task.id",
"path": "Task.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "Task.meta",
"path": "Task.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "Task.implicitRules",
"path": "Task.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "Task.language",
"path": "Task.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "Task.text",
"path": "Task.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "Task.contained",
"path": "Task.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Task.extension",
"path": "Task.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Task.modifierExtension",
"path": "Task.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Task.identifier",
"path": "Task.identifier",
"short": "Task Instance Identifier",
"definition": "The business identifier for this task.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier, Event.identifier"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Task.definition[x]",
"path": "Task.definition[x]",
"short": "Formal definition of task",
"definition": "A reference to a formal or informal definition of the task. For example, a protocol, a step within a defined workflow definition, etc.",
"requirements": "Enables a formal definition of how he task is to be performed (e.g. using BPMN, BPEL, XPDL or other formal notation) to be associated with a task, enabling automation.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.definition, Event.definition"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target"
}
]
},
{
"id": "Task.basedOn",
"path": "Task.basedOn",
"short": "Request fulfilled by this task",
"definition": "BasedOn refers to a higher-level authorization that triggered the creation of the task. It references a \"request\" resource such as a ProcedureRequest, MedicationRequest, ProcedureRequest, CarePlan, etc. which is distinct from the \"request\" resource the task is seeking to fulfil. This latter resource is referenced by FocusOn. For example, based on a ProcedureRequest (= BasedOn), a task is created to fulfil a procedureRequest ( = FocusOn ) to collect a specimen from a patient.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.basedOn, Definition.basedOn"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target[moodCode=INT]"
}
]
},
{
"id": "Task.groupIdentifier",
"path": "Task.groupIdentifier",
"short": "Requisition or grouper id",
"definition": "An identifier that links together multiple tasks and other requests that were created in the same context.",
"requirements": "Billing and/or reporting can be linked to whether multiple requests were created as a single unit.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.groupIdentifier"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[moodCode=INT].id"
}
]
},
{
"id": "Task.partOf",
"path": "Task.partOf",
"short": "Composite task",
"definition": "Task that this particular task is part of.",
"comment": "This should usually be 0..1.",
"requirements": "Allows tasks to be broken down into sub-steps (and this division can occur independent of the original task).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Task"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.partOf"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[moodCode=INT]"
}
]
},
{
"id": "Task.status",
"path": "Task.status",
"short": "draft | requested | received | accepted | +",
"definition": "The current status of the task.",
"requirements": "These states enable coordination of task status with off-the-shelf workflow solutions that support automation of tasks.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskStatus"
}
],
"strength": "required",
"description": "The current status of the task.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/task-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status, Event.status"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Task.statusReason",
"path": "Task.statusReason",
"short": "Reason for current status",
"definition": "An explanation as to why this task is held, failed, was refused, etc.",
"comment": "This applies to the current status. Look at the history of the task to see reasons for past statuses.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskStatusReason"
}
],
"strength": "example",
"description": "Codes to identify the reason for current status. These will typically be specific to a particular workflow."
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=CACT, moodCode=EVN, code=\"status change\"].reasonCode"
}
]
},
{
"id": "Task.businessStatus",
"path": "Task.businessStatus",
"short": "E.g. \"Specimen collected\", \"IV prepped\"",
"definition": "Contains business-specific nuances of the business state.",
"requirements": "There's often a need to track substates of a task - this is often variable by specific workflow implementation.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskBusinessStatus"
}
],
"strength": "example",
"description": "The domain-specific business-contextual sub-state of the task. For example: \"Blood drawn\", \"IV inserted\", \"Awaiting physician signature\", etc."
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"business status\"]"
}
]
},
{
"id": "Task.intent",
"path": "Task.intent",
"short": "proposal | plan | order +",
"definition": "Indicates the \"level\" of actionability associated with the Task. I.e. Is this a proposed task, a planned task, an actionable task, etc.",
"comment": "This element is immutable. Proposed tasks, planned tasks, etc. must be distinct instances.\n\nIn most cases, Tasks will have an intent of \"order\".",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskIntent"
}
],
"strength": "required",
"description": "Distinguishes whether the task is a proposal, plan or full order",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-intent"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.intent"
},
{
"identity": "rim",
"map": ".moodCode"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Task.priority",
"path": "Task.priority",
"short": "normal | urgent | asap | stat",
"definition": "Indicates how quickly the Task should be addressed with respect to other requests.",
"requirements": "Used to identify the service level expected while performing a task.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "If missing, this task should be performed with normal priority",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskPriority"
}
],
"strength": "required",
"description": "The task's priority",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-priority"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.priority"
},
{
"identity": "rim",
"map": ".priorityCode"
},
{
"identity": "w5",
"map": "grade"
}
]
},
{
"id": "Task.code",
"path": "Task.code",
"short": "Task Type",
"definition": "A name or code (or both) briefly describing what the task involves.",
"comment": "The title (eg \"My Tasks\", \"Outstanding Tasks for Patient X\") should go into the code.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskCode"
}
],
"strength": "example",
"description": "Codes to identify what the task involves. These will typically be specific to a particular workflow."
},
"mapping": [
{
"identity": "workflow",
"map": "Request.code, Event.code"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Task.description",
"path": "Task.description",
"short": "Human-readable explanation of task",
"definition": "A free-text description of what is to be performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "Task.focus",
"path": "Task.focus",
"short": "What task is acting on",
"definition": "The request being actioned or the resource being manipulated by this task.",
"comment": "If multiple resources need to be manipulated, use sub-tasks. (This ensures that status can be tracked independently for each referenced resource.).",
"requirements": "Used to identify the thing to be done.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=SUBJ].target"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Task.for",
"path": "Task.for",
"short": "Beneficiary of the Task",
"definition": "The entity who benefits from the performance of the service specified in the task (e.g., the patient).",
"requirements": "Used to track tasks outstanding for a beneficiary. Do not use to track the task owner or creator (see owner and creator respectively). This can also affect access control.",
"alias": [
"Patient"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.subject, Event.subject"
},
{
"identity": "rim",
"map": ".participation[typeCode=RCT].role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Task.context",
"path": "Task.context",
"short": "Healthcare event during which this task originated",
"definition": "The healthcare event (e.g. a patient and healthcare provider interaction) during which this task was created.",
"requirements": "For some tasks it may be important to know the link between the task or episode of care the task originated within.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.context, Event.context"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=PCPR, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "Task.executionPeriod",
"path": "Task.executionPeriod",
"short": "Start and end time of execution",
"definition": "Identifies the time action was first taken against the task (start) and/or the time final action was taken against the task prior to marking it as completed (end).",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence[x]"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Task.authoredOn",
"path": "Task.authoredOn",
"short": "Task Creation Date",
"definition": "The date and time this task was created.",
"requirements": "Most often used along with lastUpdated to track duration of task to supporting monitoring and management.",
"alias": [
"Created Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"condition": [
"inv-1"
],
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "Task.lastModified",
"path": "Task.lastModified",
"short": "Task Last Modified Date",
"definition": "The date and time of last modification to this task.",
"requirements": "Used along with history to track task activity and time in a particular task state. This enables monitoring and management.",
"alias": [
"Update Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"condition": [
"inv-1"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ, ].source[classCode=CACT, moodCode=EVN].effectiveTime"
}
]
},
{
"id": "Task.requester",
"path": "Task.requester",
"short": "Who is asking for task to be done",
"definition": "The creator of the task.",
"requirements": "Identifies who created this task. May be used by access control mechanisms (e.g., to ensure that only the creator can cancel a task).",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
}
]
},
{
"id": "Task.requester.id",
"path": "Task.requester.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Task.requester.extension",
"path": "Task.requester.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Task.requester.modifierExtension",
"path": "Task.requester.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Task.requester.agent",
"path": "Task.requester.agent",
"short": "Individual asking for task",
"definition": "The device, practitioner, etc. who initiated the task.",
"alias": [
"Initiator",
"Author"
],
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.agent"
},
{
"identity": "rim",
"map": ".player"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "Task.requester.onBehalfOf",
"path": "Task.requester.onBehalfOf",
"short": "Organization individual is acting for",
"definition": "The organization the device or practitioner was acting on behalf of when they initiated the task.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when authoring the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.onBehalfOf"
},
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "Task.performerType",
"path": "Task.performerType",
"short": "requester | dispatcher | scheduler | performer | monitor | manager | acquirer | reviewer",
"definition": "The type of participant that can execute the task.",
"requirements": "Use to distinguish tasks on different activity queues.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskPerformerType"
}
],
"strength": "preferred",
"description": "The type(s) of task performers allowed",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/task-performer-type"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.role, Request.performerType"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF].role.code"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Task.owner",
"path": "Task.owner",
"short": "Responsible individual",
"definition": "Individual organization or Device currently responsible for task execution.",
"comment": "Tasks may be created with an owner not yet identified.",
"requirements": "Identifies who is expected to perform this task.",
"alias": [
"Performer",
"Executer"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.actor, Request.performer"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF].role"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Task.reason",
"path": "Task.reason",
"short": "Why task is needed",
"definition": "A description or code indicating why this task needs to be performed.",
"comment": "This should only be included if there is no focus or if it differs from the reason indicated on the focus.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskReason"
}
],
"strength": "example",
"description": "Indicates why the task is needed. E.g. Suspended because patient admitted to hospital."
},
"mapping": [
{
"identity": "workflow",
"map": "Request.reasonCode, Event.reasonCodeableConcept"
},
{
"identity": "rim",
"map": ".reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Task.note",
"path": "Task.note",
"short": "Comments made about the task",
"definition": "Free-text information captured about the task as it progresses.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.note, Event.note"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ, ].source[classCode=OBS, moodCode=EVN, code=\"annotation\"].value(string)"
}
]
},
{
"id": "Task.relevantHistory",
"path": "Task.relevantHistory",
"short": "Key events in history of the Task",
"definition": "Links to Provenance records for past versions of this Task that identify key state transitions or updates that are likely to be relevant to a user looking at the current version of the task.",
"comment": "This element does not point to the Provenance associated with the *current* version of the resource - as it would be created after this version existed. The Provenance for the current version can be retrieved with a _revinclude.",
"alias": [
"Status History"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.relevantHistory"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
},
{
"id": "Task.restriction",
"path": "Task.restriction",
"short": "Constraints on fulfillment tasks",
"definition": "If the Task.focus is a request resource and the task is seeking fulfillment (i.e is asking for the request to be actioned), this element identifies any limitations on what parts of the referenced request should be actioned.",
"requirements": "Sometimes when fulfillment is sought, you don't want full fulfillment.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": "Instead of pointing to request, would point to component of request, having these characteristics"
}
]
},
{
"id": "Task.restriction.id",
"path": "Task.restriction.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Task.restriction.extension",
"path": "Task.restriction.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Task.restriction.modifierExtension",
"path": "Task.restriction.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Task.restriction.repetitions",
"path": "Task.restriction.repetitions",
"short": "How many times to repeat",
"definition": "Indicates the number of times the requested action should occur.",
"requirements": "E.g. order that requests monthly lab tests, fulfillment is sought for 1.",
"min": 0,
"max": "1",
"type": [
{
"code": "positiveInt"
}
],
"mapping": [
{
"identity": "rim",
"map": ".repeatNumber"
}
]
},
{
"id": "Task.restriction.period",
"path": "Task.restriction.period",
"short": "When fulfillment sought",
"definition": "Over what time-period is fulfillment sought.",
"comment": "Note that period.high is the due date representing the time by which the task should be completed.",
"requirements": "E.g. order that authorizes 1 year's services. Fulfillment is sought for next 3 months.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime(IVL)"
}
]
},
{
"id": "Task.restriction.recipient",
"path": "Task.restriction.recipient",
"short": "For whom is fulfillment sought?",
"definition": "For requests that are targeted to more than on potential recipient/target, for whom is fulfillment sought?",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
}
]
},
{
"id": "Task.input",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Parameter"
}
],
"path": "Task.input",
"short": "Information used to perform task",
"definition": "Additional information that may be needed in the execution of the task.",
"requirements": "Resources and data used to perform the task. This data is used in the business logic of task execution, and is stored separately because it varies between workflows.",
"alias": [
"Supporting Information"
],
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
},
{
"id": "Task.input.id",
"path": "Task.input.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Task.input.extension",
"path": "Task.input.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Task.input.modifierExtension",
"path": "Task.input.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Task.input.type",
"path": "Task.input.type",
"short": "Label for the input",
"definition": "A code or description indicating how the input is intended to be used as part of the task execution.",
"comment": "If referencing a BPMN workflow or Protocol, the \"system\" is the URL for the workflow definition and the code is the \"name\" of the required input.",
"requirements": "Inputs are named to enable task automation to bind data and pass it from one task to the next.",
"alias": [
"Name"
],
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskInputParameterType"
}
],
"strength": "example",
"description": "Codes to identify types of input parameters. These will typically be specific to a particular workflow. E.g. \"Comparison source\", \"Applicable consent\", \"Concommitent Medications\", etc."
},
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
},
{
"id": "Task.input.value[x]",
"path": "Task.input.value[x]",
"short": "Content to use in performing the task",
"definition": "The value of the input parameter as a basic type.",
"min": 1,
"max": "1",
"type": [
{
"code": "base64Binary"
},
{
"code": "boolean"
},
{
"code": "code"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "decimal"
},
{
"code": "id"
},
{
"code": "instant"
},
{
"code": "integer"
},
{
"code": "markdown"
},
{
"code": "oid"
},
{
"code": "positiveInt"
},
{
"code": "string"
},
{
"code": "time"
},
{
"code": "unsignedInt"
},
{
"code": "uri"
},
{
"code": "Address"
},
{
"code": "Age"
},
{
"code": "Annotation"
},
{
"code": "Attachment"
},
{
"code": "CodeableConcept"
},
{
"code": "Coding"
},
{
"code": "ContactPoint"
},
{
"code": "Count"
},
{
"code": "Distance"
},
{
"code": "Duration"
},
{
"code": "HumanName"
},
{
"code": "Identifier"
},
{
"code": "Money"
},
{
"code": "Period"
},
{
"code": "Quantity"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "Reference"
},
{
"code": "SampledData"
},
{
"code": "Signature"
},
{
"code": "Timing"
},
{
"code": "Meta"
}
],
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
},
{
"id": "Task.output",
"path": "Task.output",
"short": "Information produced as part of task",
"definition": "Outputs produced by the Task.",
"requirements": "Resources and data produced during the execution the task. This data is generated by the business logic of task execution, and is stored separately because it varies between workflows.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
},
{
"id": "Task.output.id",
"path": "Task.output.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Task.output.extension",
"path": "Task.output.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Task.output.modifierExtension",
"path": "Task.output.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Task.output.type",
"path": "Task.output.type",
"short": "Label for output",
"definition": "The name of the Output parameter.",
"requirements": "Outputs are named to enable task automation to bind data and pass it from one task to the next.",
"alias": [
"Name"
],
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskOutputParameterType"
}
],
"strength": "example",
"description": "Codes to identify types of input parameters. These will typically be specific to a particular workflow. E.g. \"Identified issues\", \"Preliminary results\", \"Filler order\", \"Final results\", etc."
},
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
},
{
"id": "Task.output.value[x]",
"path": "Task.output.value[x]",
"short": "Result of output",
"definition": "The value of the Output parameter as a basic type.",
"requirements": "Task outputs can take any form.",
"min": 1,
"max": "1",
"type": [
{
"code": "base64Binary"
},
{
"code": "boolean"
},
{
"code": "code"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "decimal"
},
{
"code": "id"
},
{
"code": "instant"
},
{
"code": "integer"
},
{
"code": "markdown"
},
{
"code": "oid"
},
{
"code": "positiveInt"
},
{
"code": "string"
},
{
"code": "time"
},
{
"code": "unsignedInt"
},
{
"code": "uri"
},
{
"code": "Address"
},
{
"code": "Age"
},
{
"code": "Annotation"
},
{
"code": "Attachment"
},
{
"code": "CodeableConcept"
},
{
"code": "Coding"
},
{
"code": "ContactPoint"
},
{
"code": "Count"
},
{
"code": "Distance"
},
{
"code": "Duration"
},
{
"code": "HumanName"
},
{
"code": "Identifier"
},
{
"code": "Money"
},
{
"code": "Period"
},
{
"code": "Quantity"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "Reference"
},
{
"code": "SampledData"
},
{
"code": "Signature"
},
{
"code": "Timing"
},
{
"code": "Meta"
}
],
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Task",
"path": "Task",
"short": "A task to be performed",
"definition": "A task to be performed.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "inv-1",
"severity": "error",
"human": "Last modified date must be greater than or equal to authored-on date.",
"expression": "lastModified.exists().not() or authoredOn.exists().not() or lastModified >= authoredOn",
"xpath": "not(exists(f:lastModified/@value)) or not(exists(f:authoredOn/@value)) or f:lastModified/@value >= f:authoredOn/@value"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request, Event"
},
{
"identity": "rim",
"map": "ControlAct[moodCode=INT]"
},
{
"identity": "w5",
"map": "workflow.order"
}
]
},
{
"id": "Task.identifier",
"path": "Task.identifier",
"short": "Task Instance Identifier",
"definition": "The business identifier for this task.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier, Event.identifier"
},
{
"identity": "rim",
"map": ".id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "Task.definition[x]",
"path": "Task.definition[x]",
"short": "Formal definition of task",
"definition": "A reference to a formal or informal definition of the task. For example, a protocol, a step within a defined workflow definition, etc.",
"requirements": "Enables a formal definition of how he task is to be performed (e.g. using BPMN, BPEL, XPDL or other formal notation) to be associated with a task, enabling automation.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/ActivityDefinition"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.definition, Event.definition"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=DEFN].target"
}
]
},
{
"id": "Task.basedOn",
"path": "Task.basedOn",
"short": "Request fulfilled by this task",
"definition": "BasedOn refers to a higher-level authorization that triggered the creation of the task. It references a \"request\" resource such as a ProcedureRequest, MedicationRequest, ProcedureRequest, CarePlan, etc. which is distinct from the \"request\" resource the task is seeking to fulfil. This latter resource is referenced by FocusOn. For example, based on a ProcedureRequest (= BasedOn), a task is created to fulfil a procedureRequest ( = FocusOn ) to collect a specimen from a patient.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.basedOn, Definition.basedOn"
},
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=FLFS].target[moodCode=INT]"
}
]
},
{
"id": "Task.groupIdentifier",
"path": "Task.groupIdentifier",
"short": "Requisition or grouper id",
"definition": "An identifier that links together multiple tasks and other requests that were created in the same context.",
"requirements": "Billing and/or reporting can be linked to whether multiple requests were created as a single unit.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.groupIdentifier"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[moodCode=INT].id"
}
]
},
{
"id": "Task.partOf",
"path": "Task.partOf",
"short": "Composite task",
"definition": "Task that this particular task is part of.",
"comment": "This should usually be 0..1.",
"requirements": "Allows tasks to be broken down into sub-steps (and this division can occur independent of the original task).",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Task"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.partOf"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[moodCode=INT]"
}
]
},
{
"id": "Task.status",
"path": "Task.status",
"short": "draft | requested | received | accepted | +",
"definition": "The current status of the task.",
"requirements": "These states enable coordination of task status with off-the-shelf workflow solutions that support automation of tasks.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskStatus"
}
],
"strength": "required",
"description": "The current status of the task.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/task-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status, Event.status"
},
{
"identity": "rim",
"map": ".statusCode"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "Task.statusReason",
"path": "Task.statusReason",
"short": "Reason for current status",
"definition": "An explanation as to why this task is held, failed, was refused, etc.",
"comment": "This applies to the current status. Look at the history of the task to see reasons for past statuses.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskStatusReason"
}
],
"strength": "example",
"description": "Codes to identify the reason for current status. These will typically be specific to a particular workflow."
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=CACT, moodCode=EVN, code=\"status change\"].reasonCode"
}
]
},
{
"id": "Task.businessStatus",
"path": "Task.businessStatus",
"short": "E.g. \"Specimen collected\", \"IV prepped\"",
"definition": "Contains business-specific nuances of the business state.",
"requirements": "There's often a need to track substates of a task - this is often variable by specific workflow implementation.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskBusinessStatus"
}
],
"strength": "example",
"description": "The domain-specific business-contextual sub-state of the task. For example: \"Blood drawn\", \"IV inserted\", \"Awaiting physician signature\", etc."
},
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ].source[classCode=OBS, moodCode=EVN, code=\"business status\"]"
}
]
},
{
"id": "Task.intent",
"path": "Task.intent",
"short": "proposal | plan | order +",
"definition": "Indicates the \"level\" of actionability associated with the Task. I.e. Is this a proposed task, a planned task, an actionable task, etc.",
"comment": "This element is immutable. Proposed tasks, planned tasks, etc. must be distinct instances.\n\nIn most cases, Tasks will have an intent of \"order\".",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskIntent"
}
],
"strength": "required",
"description": "Distinguishes whether the task is a proposal, plan or full order",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-intent"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.intent"
},
{
"identity": "rim",
"map": ".moodCode"
},
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "Task.priority",
"path": "Task.priority",
"short": "normal | urgent | asap | stat",
"definition": "Indicates how quickly the Task should be addressed with respect to other requests.",
"requirements": "Used to identify the service level expected while performing a task.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "If missing, this task should be performed with normal priority",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskPriority"
}
],
"strength": "required",
"description": "The task's priority",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/request-priority"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.priority"
},
{
"identity": "rim",
"map": ".priorityCode"
},
{
"identity": "w5",
"map": "grade"
}
]
},
{
"id": "Task.code",
"path": "Task.code",
"short": "Task Type",
"definition": "A name or code (or both) briefly describing what the task involves.",
"comment": "The title (eg \"My Tasks\", \"Outstanding Tasks for Patient X\") should go into the code.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskCode"
}
],
"strength": "example",
"description": "Codes to identify what the task involves. These will typically be specific to a particular workflow."
},
"mapping": [
{
"identity": "workflow",
"map": "Request.code, Event.code"
},
{
"identity": "rim",
"map": ".code"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Task.description",
"path": "Task.description",
"short": "Human-readable explanation of task",
"definition": "A free-text description of what is to be performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".text"
}
]
},
{
"id": "Task.focus",
"path": "Task.focus",
"short": "What task is acting on",
"definition": "The request being actioned or the resource being manipulated by this task.",
"comment": "If multiple resources need to be manipulated, use sub-tasks. (This ensures that status can be tracked independently for each referenced resource.).",
"requirements": "Used to identify the thing to be done.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".outboundRelationship[typeCode=SUBJ].target"
},
{
"identity": "w5",
"map": "what"
}
]
},
{
"id": "Task.for",
"path": "Task.for",
"short": "Beneficiary of the Task",
"definition": "The entity who benefits from the performance of the service specified in the task (e.g., the patient).",
"requirements": "Used to track tasks outstanding for a beneficiary. Do not use to track the task owner or creator (see owner and creator respectively). This can also affect access control.",
"alias": [
"Patient"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.subject, Event.subject"
},
{
"identity": "rim",
"map": ".participation[typeCode=RCT].role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "Task.context",
"path": "Task.context",
"short": "Healthcare event during which this task originated",
"definition": "The healthcare event (e.g. a patient and healthcare provider interaction) during which this task was created.",
"requirements": "For some tasks it may be important to know the link between the task or episode of care the task originated within.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/EpisodeOfCare"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.context, Event.context"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=COMP].source[classCode=PCPR, moodCode=EVN]"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "Task.executionPeriod",
"path": "Task.executionPeriod",
"short": "Start and end time of execution",
"definition": "Identifies the time action was first taken against the task (start) and/or the time final action was taken against the task prior to marking it as completed (end).",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.occurrence[x]"
},
{
"identity": "rim",
"map": ".effectiveTime"
},
{
"identity": "w5",
"map": "when.done"
}
]
},
{
"id": "Task.authoredOn",
"path": "Task.authoredOn",
"short": "Task Creation Date",
"definition": "The date and time this task was created.",
"requirements": "Most often used along with lastUpdated to track duration of task to supporting monitoring and management.",
"alias": [
"Created Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"condition": [
"inv-1"
],
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "Task.lastModified",
"path": "Task.lastModified",
"short": "Task Last Modified Date",
"definition": "The date and time of last modification to this task.",
"requirements": "Used along with history to track task activity and time in a particular task state. This enables monitoring and management.",
"alias": [
"Update Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"condition": [
"inv-1"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ, ].source[classCode=CACT, moodCode=EVN].effectiveTime"
}
]
},
{
"id": "Task.requester",
"path": "Task.requester",
"short": "Who is asking for task to be done",
"definition": "The creator of the task.",
"requirements": "Identifies who created this task. May be used by access control mechanisms (e.g., to ensure that only the creator can cancel a task).",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester"
},
{
"identity": "rim",
"map": ".participation[typeCode=AUT].role"
}
]
},
{
"id": "Task.requester.agent",
"path": "Task.requester.agent",
"short": "Individual asking for task",
"definition": "The device, practitioner, etc. who initiated the task.",
"alias": [
"Initiator",
"Author"
],
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.agent"
},
{
"identity": "rim",
"map": ".player"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "Task.requester.onBehalfOf",
"path": "Task.requester.onBehalfOf",
"short": "Organization individual is acting for",
"definition": "The organization the device or practitioner was acting on behalf of when they initiated the task.",
"requirements": "Practitioners and Devices can be associated with multiple organizations. This element indicates which organization they were acting on behalf of when authoring the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.onBehalfOf"
},
{
"identity": "rim",
"map": ".scoper"
}
]
},
{
"id": "Task.performerType",
"path": "Task.performerType",
"short": "requester | dispatcher | scheduler | performer | monitor | manager | acquirer | reviewer",
"definition": "The type of participant that can execute the task.",
"requirements": "Use to distinguish tasks on different activity queues.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskPerformerType"
}
],
"strength": "preferred",
"description": "The type(s) of task performers allowed",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/task-performer-type"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.role, Request.performerType"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF].role.code"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Task.owner",
"path": "Task.owner",
"short": "Responsible individual",
"definition": "Individual organization or Device currently responsible for task execution.",
"comment": "Tasks may be created with an owner not yet identified.",
"requirements": "Identifies who is expected to perform this task.",
"alias": [
"Performer",
"Executer"
],
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Device"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
}
],
"isSummary": true,
"mapping": [
{
"identity": "workflow",
"map": "Event.performer.actor, Request.performer"
},
{
"identity": "rim",
"map": ".participation[typeCode=PRF].role"
},
{
"identity": "w5",
"map": "who.actor"
}
]
},
{
"id": "Task.reason",
"path": "Task.reason",
"short": "Why task is needed",
"definition": "A description or code indicating why this task needs to be performed.",
"comment": "This should only be included if there is no focus or if it differs from the reason indicated on the focus.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskReason"
}
],
"strength": "example",
"description": "Indicates why the task is needed. E.g. Suspended because patient admitted to hospital."
},
"mapping": [
{
"identity": "workflow",
"map": "Request.reasonCode, Event.reasonCodeableConcept"
},
{
"identity": "rim",
"map": ".reasonCode"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "Task.note",
"path": "Task.note",
"short": "Comments made about the task",
"definition": "Free-text information captured about the task as it progresses.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.note, Event.note"
},
{
"identity": "rim",
"map": ".inboundRelationship[typeCode=SUBJ, ].source[classCode=OBS, moodCode=EVN, code=\"annotation\"].value(string)"
}
]
},
{
"id": "Task.relevantHistory",
"path": "Task.relevantHistory",
"short": "Key events in history of the Task",
"definition": "Links to Provenance records for past versions of this Task that identify key state transitions or updates that are likely to be relevant to a user looking at the current version of the task.",
"comment": "This element does not point to the Provenance associated with the *current* version of the resource - as it would be created after this version existed. The Provenance for the current version can be retrieved with a _revinclude.",
"alias": [
"Status History"
],
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Provenance"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.relevantHistory"
},
{
"identity": "rim",
"map": ".inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN]"
}
]
},
{
"id": "Task.restriction",
"path": "Task.restriction",
"short": "Constraints on fulfillment tasks",
"definition": "If the Task.focus is a request resource and the task is seeking fulfillment (i.e is asking for the request to be actioned), this element identifies any limitations on what parts of the referenced request should be actioned.",
"requirements": "Sometimes when fulfillment is sought, you don't want full fulfillment.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": "Instead of pointing to request, would point to component of request, having these characteristics"
}
]
},
{
"id": "Task.restriction.repetitions",
"path": "Task.restriction.repetitions",
"short": "How many times to repeat",
"definition": "Indicates the number of times the requested action should occur.",
"requirements": "E.g. order that requests monthly lab tests, fulfillment is sought for 1.",
"min": 0,
"max": "1",
"type": [
{
"code": "positiveInt"
}
],
"mapping": [
{
"identity": "rim",
"map": ".repeatNumber"
}
]
},
{
"id": "Task.restriction.period",
"path": "Task.restriction.period",
"short": "When fulfillment sought",
"definition": "Over what time-period is fulfillment sought.",
"comment": "Note that period.high is the due date representing the time by which the task should be completed.",
"requirements": "E.g. order that authorizes 1 year's services. Fulfillment is sought for next 3 months.",
"min": 0,
"max": "1",
"type": [
{
"code": "Period"
}
],
"mapping": [
{
"identity": "rim",
"map": ".effectiveTime(IVL)"
}
]
},
{
"id": "Task.restriction.recipient",
"path": "Task.restriction.recipient",
"short": "For whom is fulfillment sought?",
"definition": "For requests that are targeted to more than on potential recipient/target, for whom is fulfillment sought?",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/RelatedPerson"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Group"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Organization"
}
],
"mapping": [
{
"identity": "rim",
"map": ".participation[typeCode=SBJ].role"
}
]
},
{
"id": "Task.input",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "Parameter"
}
],
"path": "Task.input",
"short": "Information used to perform task",
"definition": "Additional information that may be needed in the execution of the task.",
"requirements": "Resources and data used to perform the task. This data is used in the business logic of task execution, and is stored separately because it varies between workflows.",
"alias": [
"Supporting Information"
],
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
},
{
"id": "Task.input.type",
"path": "Task.input.type",
"short": "Label for the input",
"definition": "A code or description indicating how the input is intended to be used as part of the task execution.",
"comment": "If referencing a BPMN workflow or Protocol, the \"system\" is the URL for the workflow definition and the code is the \"name\" of the required input.",
"requirements": "Inputs are named to enable task automation to bind data and pass it from one task to the next.",
"alias": [
"Name"
],
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskInputParameterType"
}
],
"strength": "example",
"description": "Codes to identify types of input parameters. These will typically be specific to a particular workflow. E.g. \"Comparison source\", \"Applicable consent\", \"Concommitent Medications\", etc."
},
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
},
{
"id": "Task.input.value[x]",
"path": "Task.input.value[x]",
"short": "Content to use in performing the task",
"definition": "The value of the input parameter as a basic type.",
"min": 1,
"max": "1",
"type": [
{
"code": "base64Binary"
},
{
"code": "boolean"
},
{
"code": "code"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "decimal"
},
{
"code": "id"
},
{
"code": "instant"
},
{
"code": "integer"
},
{
"code": "markdown"
},
{
"code": "oid"
},
{
"code": "positiveInt"
},
{
"code": "string"
},
{
"code": "time"
},
{
"code": "unsignedInt"
},
{
"code": "uri"
},
{
"code": "Address"
},
{
"code": "Age"
},
{
"code": "Annotation"
},
{
"code": "Attachment"
},
{
"code": "CodeableConcept"
},
{
"code": "Coding"
},
{
"code": "ContactPoint"
},
{
"code": "Count"
},
{
"code": "Distance"
},
{
"code": "Duration"
},
{
"code": "HumanName"
},
{
"code": "Identifier"
},
{
"code": "Money"
},
{
"code": "Period"
},
{
"code": "Quantity"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "Reference"
},
{
"code": "SampledData"
},
{
"code": "Signature"
},
{
"code": "Timing"
},
{
"code": "Meta"
}
],
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
},
{
"id": "Task.output",
"path": "Task.output",
"short": "Information produced as part of task",
"definition": "Outputs produced by the Task.",
"requirements": "Resources and data produced during the execution the task. This data is generated by the business logic of task execution, and is stored separately because it varies between workflows.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
},
{
"id": "Task.output.type",
"path": "Task.output.type",
"short": "Label for output",
"definition": "The name of the Output parameter.",
"requirements": "Outputs are named to enable task automation to bind data and pass it from one task to the next.",
"alias": [
"Name"
],
"min": 1,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TaskOutputParameterType"
}
],
"strength": "example",
"description": "Codes to identify types of input parameters. These will typically be specific to a particular workflow. E.g. \"Identified issues\", \"Preliminary results\", \"Filler order\", \"Final results\", etc."
},
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
},
{
"id": "Task.output.value[x]",
"path": "Task.output.value[x]",
"short": "Result of output",
"definition": "The value of the Output parameter as a basic type.",
"requirements": "Task outputs can take any form.",
"min": 1,
"max": "1",
"type": [
{
"code": "base64Binary"
},
{
"code": "boolean"
},
{
"code": "code"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "decimal"
},
{
"code": "id"
},
{
"code": "instant"
},
{
"code": "integer"
},
{
"code": "markdown"
},
{
"code": "oid"
},
{
"code": "positiveInt"
},
{
"code": "string"
},
{
"code": "time"
},
{
"code": "unsignedInt"
},
{
"code": "uri"
},
{
"code": "Address"
},
{
"code": "Age"
},
{
"code": "Annotation"
},
{
"code": "Attachment"
},
{
"code": "CodeableConcept"
},
{
"code": "Coding"
},
{
"code": "ContactPoint"
},
{
"code": "Count"
},
{
"code": "Distance"
},
{
"code": "Duration"
},
{
"code": "HumanName"
},
{
"code": "Identifier"
},
{
"code": "Money"
},
{
"code": "Period"
},
{
"code": "Quantity"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "Reference"
},
{
"code": "SampledData"
},
{
"code": "Signature"
},
{
"code": "Timing"
},
{
"code": "Meta"
}
],
"mapping": [
{
"identity": "rim",
"map": "???"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/TestReport",
"resource": {
"resourceType": "StructureDefinition",
"id": "TestReport",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints TestReport DomainResource Describes the results of a TestScript execution
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier Σ 0..1 Identifier External identifier name Σ 0..1 string Informal name of the executed TestScript status ?!Σ 1..1 code completed | in-progress | waiting | stopped | entered-in-error
TestReportStatus (Required) testScript Σ 1..1 Reference(TestScript) Reference to the version-specific TestScript that was executed to produce this TestReport result Σ 1..1 code pass | fail | pending
TestReportResult (Required) score Σ 0..1 decimal The final score (percentage of tests passed) resulting from the execution of the TestScript tester Σ 0..1 string Name of the tester producing this report (Organization or individual) issued Σ 0..1 dateTime When the TestScript was executed and this TestReport was generated participant 0..* BackboneElement A participant in the test execution, either the execution engine, a client, or a server
type 1..1 code test-engine | client | server
TestReportParticipantType (Required) uri 1..1 uri The uri of the participant. An absolute URL is preferred display 0..1 string The display name of the participant setup 0..1 BackboneElement The results of the series of required setup operations before the tests were executed action I 1..* BackboneElement A setup operation or assert that was executed
+ Setup action SHALL contain either an operation or assert but not both.
operation 0..1 BackboneElement The operation to perform result 1..1 code pass | skip | fail | warning | error
TestReportActionResult (Required) message 0..1 markdown A message associated with the result detail 0..1 uri A link to further details on the result assert 0..1 BackboneElement The assertion to perform result 1..1 code pass | skip | fail | warning | error
TestReportActionResult (Required) message 0..1 markdown A message associated with the result detail 0..1 string A link to further details on the result test 0..* BackboneElement A test executed from the test script
name 0..1 string Tracking/logging name of this test description 0..1 string Tracking/reporting short description of the test action I 1..* BackboneElement A test operation or assert that was performed
+ Test action SHALL contain either an operation or assert but not both.
operation 0..1 see operation The operation performed assert 0..1 see assert The assertion performed teardown 0..1 BackboneElement The results of running the series of required clean up steps action 1..* BackboneElement One or more teardown operations performed
operation 1..1 see operation The teardown operation performed
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 0
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/TestReport",
"name": "TestReport",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for TestReport Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "objimpl",
"uri": "http://hl7.org/fhir/object-implementation",
"name": "Object Implementation Information"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "TestReport",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "TestReport",
"path": "TestReport",
"short": "Describes the results of a TestScript execution",
"definition": "A summary of information based on the results of executing a TestScript.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "objimpl",
"map": "BaseConformance"
},
{
"identity": "w5",
"map": "conformance.misc"
}
]
},
{
"id": "TestReport.id",
"path": "TestReport.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "TestReport.meta",
"path": "TestReport.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "TestReport.implicitRules",
"path": "TestReport.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "TestReport.language",
"path": "TestReport.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "TestReport.text",
"path": "TestReport.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "TestReport.contained",
"path": "TestReport.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.extension",
"path": "TestReport.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.modifierExtension",
"path": "TestReport.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.identifier",
"path": "TestReport.identifier",
"short": "External identifier",
"definition": "Identifier for the TestScript assigned for external purposes outside the context of FHIR.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "TestReport.name",
"path": "TestReport.name",
"short": "Informal name of the executed TestScript",
"definition": "A free text natural language name identifying the executed TestScript.",
"comment": "Not expected to be globally unique.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "BaseConformance.name"
}
]
},
{
"id": "TestReport.status",
"path": "TestReport.status",
"short": "completed | in-progress | waiting | stopped | entered-in-error",
"definition": "The current state of this test report.",
"comment": "The status represents where the execution is currently within the test script execution life cycle.\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestReportStatus"
}
],
"strength": "required",
"description": "The current status of the test report.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/report-status-codes"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "TestReport.testScript",
"path": "TestReport.testScript",
"short": "Reference to the version-specific TestScript that was executed to produce this TestReport",
"definition": "Ideally this is an absolute URL that is used to identify the version-specific TestScript that was executed, matching the `TestScript.url`.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/TestScript"
}
],
"isSummary": true
},
{
"id": "TestReport.result",
"path": "TestReport.result",
"short": "pass | fail | pending",
"definition": "The overall result from the execution of the TestScript.",
"comment": "The pass and fail result represents a completed test script execution. The pending result represents a test script execution that has not yet started or is currently in progress.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestReportResult"
}
],
"strength": "required",
"description": "The reported execution result.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/report-result-codes"
}
}
},
{
"id": "TestReport.score",
"path": "TestReport.score",
"short": "The final score (percentage of tests passed) resulting from the execution of the TestScript",
"definition": "The final score (percentage of tests passed) resulting from the execution of the TestScript.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "TestReport.tester",
"path": "TestReport.tester",
"short": "Name of the tester producing this report (Organization or individual)",
"definition": "Name of the tester producing this report (Organization or individual).",
"comment": "Usually an organization, but may be an individual. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the TestReport. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "TestReport.issued",
"path": "TestReport.issued",
"short": "When the TestScript was executed and this TestReport was generated",
"definition": "When the TestScript was executed and this TestReport was generated.",
"comment": "Additional specific dates may be added as extensions.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "BaseConformance.date"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "TestReport.participant",
"path": "TestReport.participant",
"short": "A participant in the test execution, either the execution engine, a client, or a server",
"definition": "A participant in the test execution, either the execution engine, a client, or a server.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestReport.participant.id",
"path": "TestReport.participant.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.participant.extension",
"path": "TestReport.participant.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.participant.modifierExtension",
"path": "TestReport.participant.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.participant.type",
"path": "TestReport.participant.type",
"short": "test-engine | client | server",
"definition": "The type of participant.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestReportParticipantType"
}
],
"strength": "required",
"description": "The type of participant.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/report-participant-type"
}
}
},
{
"id": "TestReport.participant.uri",
"path": "TestReport.participant.uri",
"short": "The uri of the participant. An absolute URL is preferred",
"definition": "The uri of the participant. An absolute URL is preferred.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "TestReport.participant.display",
"path": "TestReport.participant.display",
"short": "The display name of the participant",
"definition": "The display name of the participant.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestReport.setup",
"path": "TestReport.setup",
"short": "The results of the series of required setup operations before the tests were executed",
"definition": "The results of the series of required setup operations before the tests were executed.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestReport.setup.id",
"path": "TestReport.setup.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.setup.extension",
"path": "TestReport.setup.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.setup.modifierExtension",
"path": "TestReport.setup.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.setup.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "SetupAction"
}
],
"path": "TestReport.setup.action",
"short": "A setup operation or assert that was executed",
"definition": "Action would contain either an operation or an assertion.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "inv-1",
"severity": "error",
"human": "Setup action SHALL contain either an operation or assert but not both.",
"expression": "operation.exists() xor assert.exists()",
"xpath": "(f:operation or f:assert) and not(f:operation and f:assert)"
}
]
},
{
"id": "TestReport.setup.action.id",
"path": "TestReport.setup.action.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.setup.action.extension",
"path": "TestReport.setup.action.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.setup.action.modifierExtension",
"path": "TestReport.setup.action.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.setup.action.operation",
"path": "TestReport.setup.action.operation",
"short": "The operation to perform",
"definition": "The operation performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestReport.setup.action.operation.id",
"path": "TestReport.setup.action.operation.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.setup.action.operation.extension",
"path": "TestReport.setup.action.operation.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.setup.action.operation.modifierExtension",
"path": "TestReport.setup.action.operation.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.setup.action.operation.result",
"path": "TestReport.setup.action.operation.result",
"short": "pass | skip | fail | warning | error",
"definition": "The result of this operation.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestReportActionResult"
}
],
"strength": "required",
"description": "The results of executing an action.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/report-action-result-codes"
}
}
},
{
"id": "TestReport.setup.action.operation.message",
"path": "TestReport.setup.action.operation.message",
"short": "A message associated with the result",
"definition": "An explanatory message associated with the result.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "TestReport.setup.action.operation.detail",
"path": "TestReport.setup.action.operation.detail",
"short": "A link to further details on the result",
"definition": "A link to further details on the result.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "TestReport.setup.action.assert",
"path": "TestReport.setup.action.assert",
"short": "The assertion to perform",
"definition": "The results of the assertion performed on the previous operations.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestReport.setup.action.assert.id",
"path": "TestReport.setup.action.assert.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.setup.action.assert.extension",
"path": "TestReport.setup.action.assert.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.setup.action.assert.modifierExtension",
"path": "TestReport.setup.action.assert.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.setup.action.assert.result",
"path": "TestReport.setup.action.assert.result",
"short": "pass | skip | fail | warning | error",
"definition": "The result of this assertion.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestReportActionResult"
}
],
"strength": "required",
"description": "The results of executing an action.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/report-action-result-codes"
}
}
},
{
"id": "TestReport.setup.action.assert.message",
"path": "TestReport.setup.action.assert.message",
"short": "A message associated with the result",
"definition": "An explanatory message associated with the result.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "TestReport.setup.action.assert.detail",
"path": "TestReport.setup.action.assert.detail",
"short": "A link to further details on the result",
"definition": "A link to further details on the result.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestReport.test",
"path": "TestReport.test",
"short": "A test executed from the test script",
"definition": "A test executed from the test script.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestReport.test.id",
"path": "TestReport.test.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.test.extension",
"path": "TestReport.test.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.test.modifierExtension",
"path": "TestReport.test.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.test.name",
"path": "TestReport.test.name",
"short": "Tracking/logging name of this test",
"definition": "The name of this test used for tracking/logging purposes by test engines.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestReport.test.description",
"path": "TestReport.test.description",
"short": "Tracking/reporting short description of the test",
"definition": "A short description of the test used by test engines for tracking and reporting purposes.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestReport.test.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "TestAction"
}
],
"path": "TestReport.test.action",
"short": "A test operation or assert that was performed",
"definition": "Action would contain either an operation or an assertion.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "inv-2",
"severity": "error",
"human": "Test action SHALL contain either an operation or assert but not both.",
"expression": "operation.exists() xor assert.exists()",
"xpath": "(f:operation or f:assert) and not(f:operation and f:assert)"
}
]
},
{
"id": "TestReport.test.action.id",
"path": "TestReport.test.action.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.test.action.extension",
"path": "TestReport.test.action.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.test.action.modifierExtension",
"path": "TestReport.test.action.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.test.action.operation",
"path": "TestReport.test.action.operation",
"short": "The operation performed",
"definition": "An operation would involve a REST request to a server.",
"min": 0,
"max": "1",
"contentReference": "#TestReport.setup.action.operation"
},
{
"id": "TestReport.test.action.assert",
"path": "TestReport.test.action.assert",
"short": "The assertion performed",
"definition": "The results of the assertion performed on the previous operations.",
"min": 0,
"max": "1",
"contentReference": "#TestReport.setup.action.assert"
},
{
"id": "TestReport.teardown",
"path": "TestReport.teardown",
"short": "The results of running the series of required clean up steps",
"definition": "The results of the series of operations required to clean up after the all the tests were executed (successfully or otherwise).",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestReport.teardown.id",
"path": "TestReport.teardown.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.teardown.extension",
"path": "TestReport.teardown.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.teardown.modifierExtension",
"path": "TestReport.teardown.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.teardown.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "TeardownAction"
}
],
"path": "TestReport.teardown.action",
"short": "One or more teardown operations performed",
"definition": "The teardown action will only contain an operation.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestReport.teardown.action.id",
"path": "TestReport.teardown.action.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.teardown.action.extension",
"path": "TestReport.teardown.action.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestReport.teardown.action.modifierExtension",
"path": "TestReport.teardown.action.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestReport.teardown.action.operation",
"path": "TestReport.teardown.action.operation",
"short": "The teardown operation performed",
"definition": "An operation would involve a REST request to a server.",
"min": 1,
"max": "1",
"contentReference": "#TestReport.setup.action.operation"
}
]
},
"differential": {
"element": [
{
"id": "TestReport",
"path": "TestReport",
"short": "Describes the results of a TestScript execution",
"definition": "A summary of information based on the results of executing a TestScript.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "objimpl",
"map": "BaseConformance"
},
{
"identity": "w5",
"map": "conformance.misc"
}
]
},
{
"id": "TestReport.identifier",
"path": "TestReport.identifier",
"short": "External identifier",
"definition": "Identifier for the TestScript assigned for external purposes outside the context of FHIR.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "TestReport.name",
"path": "TestReport.name",
"short": "Informal name of the executed TestScript",
"definition": "A free text natural language name identifying the executed TestScript.",
"comment": "Not expected to be globally unique.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "BaseConformance.name"
}
]
},
{
"id": "TestReport.status",
"path": "TestReport.status",
"short": "completed | in-progress | waiting | stopped | entered-in-error",
"definition": "The current state of this test report.",
"comment": "The status represents where the execution is currently within the test script execution life cycle.\n\nThis element is labeled as a modifier because the status contains codes that mark the resource as not currently valid.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestReportStatus"
}
],
"strength": "required",
"description": "The current status of the test report.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/report-status-codes"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "TestReport.testScript",
"path": "TestReport.testScript",
"short": "Reference to the version-specific TestScript that was executed to produce this TestReport",
"definition": "Ideally this is an absolute URL that is used to identify the version-specific TestScript that was executed, matching the `TestScript.url`.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/TestScript"
}
],
"isSummary": true
},
{
"id": "TestReport.result",
"path": "TestReport.result",
"short": "pass | fail | pending",
"definition": "The overall result from the execution of the TestScript.",
"comment": "The pass and fail result represents a completed test script execution. The pending result represents a test script execution that has not yet started or is currently in progress.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestReportResult"
}
],
"strength": "required",
"description": "The reported execution result.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/report-result-codes"
}
}
},
{
"id": "TestReport.score",
"path": "TestReport.score",
"short": "The final score (percentage of tests passed) resulting from the execution of the TestScript",
"definition": "The final score (percentage of tests passed) resulting from the execution of the TestScript.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
],
"isSummary": true
},
{
"id": "TestReport.tester",
"path": "TestReport.tester",
"short": "Name of the tester producing this report (Organization or individual)",
"definition": "Name of the tester producing this report (Organization or individual).",
"comment": "Usually an organization, but may be an individual. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the TestReport. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "TestReport.issued",
"path": "TestReport.issued",
"short": "When the TestScript was executed and this TestReport was generated",
"definition": "When the TestScript was executed and this TestReport was generated.",
"comment": "Additional specific dates may be added as extensions.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "BaseConformance.date"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "TestReport.participant",
"path": "TestReport.participant",
"short": "A participant in the test execution, either the execution engine, a client, or a server",
"definition": "A participant in the test execution, either the execution engine, a client, or a server.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestReport.participant.type",
"path": "TestReport.participant.type",
"short": "test-engine | client | server",
"definition": "The type of participant.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestReportParticipantType"
}
],
"strength": "required",
"description": "The type of participant.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/report-participant-type"
}
}
},
{
"id": "TestReport.participant.uri",
"path": "TestReport.participant.uri",
"short": "The uri of the participant. An absolute URL is preferred",
"definition": "The uri of the participant. An absolute URL is preferred.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "TestReport.participant.display",
"path": "TestReport.participant.display",
"short": "The display name of the participant",
"definition": "The display name of the participant.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestReport.setup",
"path": "TestReport.setup",
"short": "The results of the series of required setup operations before the tests were executed",
"definition": "The results of the series of required setup operations before the tests were executed.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestReport.setup.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "SetupAction"
}
],
"path": "TestReport.setup.action",
"short": "A setup operation or assert that was executed",
"definition": "Action would contain either an operation or an assertion.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "inv-1",
"severity": "error",
"human": "Setup action SHALL contain either an operation or assert but not both.",
"expression": "operation.exists() xor assert.exists()",
"xpath": "(f:operation or f:assert) and not(f:operation and f:assert)"
}
]
},
{
"id": "TestReport.setup.action.operation",
"path": "TestReport.setup.action.operation",
"short": "The operation to perform",
"definition": "The operation performed.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestReport.setup.action.operation.result",
"path": "TestReport.setup.action.operation.result",
"short": "pass | skip | fail | warning | error",
"definition": "The result of this operation.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestReportActionResult"
}
],
"strength": "required",
"description": "The results of executing an action.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/report-action-result-codes"
}
}
},
{
"id": "TestReport.setup.action.operation.message",
"path": "TestReport.setup.action.operation.message",
"short": "A message associated with the result",
"definition": "An explanatory message associated with the result.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "TestReport.setup.action.operation.detail",
"path": "TestReport.setup.action.operation.detail",
"short": "A link to further details on the result",
"definition": "A link to further details on the result.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "TestReport.setup.action.assert",
"path": "TestReport.setup.action.assert",
"short": "The assertion to perform",
"definition": "The results of the assertion performed on the previous operations.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestReport.setup.action.assert.result",
"path": "TestReport.setup.action.assert.result",
"short": "pass | skip | fail | warning | error",
"definition": "The result of this assertion.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestReportActionResult"
}
],
"strength": "required",
"description": "The results of executing an action.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/report-action-result-codes"
}
}
},
{
"id": "TestReport.setup.action.assert.message",
"path": "TestReport.setup.action.assert.message",
"short": "A message associated with the result",
"definition": "An explanatory message associated with the result.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "TestReport.setup.action.assert.detail",
"path": "TestReport.setup.action.assert.detail",
"short": "A link to further details on the result",
"definition": "A link to further details on the result.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestReport.test",
"path": "TestReport.test",
"short": "A test executed from the test script",
"definition": "A test executed from the test script.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestReport.test.name",
"path": "TestReport.test.name",
"short": "Tracking/logging name of this test",
"definition": "The name of this test used for tracking/logging purposes by test engines.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestReport.test.description",
"path": "TestReport.test.description",
"short": "Tracking/reporting short description of the test",
"definition": "A short description of the test used by test engines for tracking and reporting purposes.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestReport.test.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "TestAction"
}
],
"path": "TestReport.test.action",
"short": "A test operation or assert that was performed",
"definition": "Action would contain either an operation or an assertion.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "inv-2",
"severity": "error",
"human": "Test action SHALL contain either an operation or assert but not both.",
"expression": "operation.exists() xor assert.exists()",
"xpath": "(f:operation or f:assert) and not(f:operation and f:assert)"
}
]
},
{
"id": "TestReport.test.action.operation",
"path": "TestReport.test.action.operation",
"short": "The operation performed",
"definition": "An operation would involve a REST request to a server.",
"min": 0,
"max": "1",
"contentReference": "#TestReport.setup.action.operation"
},
{
"id": "TestReport.test.action.assert",
"path": "TestReport.test.action.assert",
"short": "The assertion performed",
"definition": "The results of the assertion performed on the previous operations.",
"min": 0,
"max": "1",
"contentReference": "#TestReport.setup.action.assert"
},
{
"id": "TestReport.teardown",
"path": "TestReport.teardown",
"short": "The results of running the series of required clean up steps",
"definition": "The results of the series of operations required to clean up after the all the tests were executed (successfully or otherwise).",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestReport.teardown.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "TeardownAction"
}
],
"path": "TestReport.teardown.action",
"short": "One or more teardown operations performed",
"definition": "The teardown action will only contain an operation.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestReport.teardown.action.operation",
"path": "TestReport.teardown.action.operation",
"short": "The teardown operation performed",
"definition": "An operation would involve a REST request to a server.",
"min": 1,
"max": "1",
"contentReference": "#TestReport.setup.action.operation"
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/TestScript",
"resource": {
"resourceType": "StructureDefinition",
"id": "TestScript",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints TestScript DomainResource Describes a set of tests
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension url Σ 1..1 uri Logical URI to reference this test script (globally unique) identifier Σ 0..1 Identifier Additional identifier for the test script version Σ 0..1 string Business version of the test script name Σ 1..1 string Name for this test script (computer friendly) title Σ 0..1 string Name for this test script (human friendly) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) experimental ?!Σ 0..1 boolean For testing purposes, not real usage date Σ 0..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) contact Σ 0..* ContactDetail Contact details for the publisher
description 0..1 markdown Natural language description of the test script useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for test script (if applicable)
Jurisdiction ValueSet (Extensible)
purpose 0..1 markdown Why this test script is defined copyright 0..1 markdown Use and/or publishing restrictions origin 0..* BackboneElement An abstract server representing a client or sender in a message exchange
index 1..1 integer The index of the abstract origin server starting at 1 profile 1..1 Coding FHIR-Client | FHIR-SDC-FormFiller
TestScriptProfileOriginType (Extensible) destination 0..* BackboneElement An abstract server representing a destination or receiver in a message exchange
index 1..1 integer The index of the abstract destination server starting at 1 profile 1..1 Coding FHIR-Server | FHIR-SDC-FormManager | FHIR-SDC-FormReceiver | FHIR-SDC-FormProcessor
TestScriptProfileDestinationType (Extensible) metadata I 0..1 BackboneElement Required capability that is assumed to function correctly on the FHIR server being tested
+ TestScript metadata capability SHALL contain required or validated or both. link 0..* BackboneElement Links to the FHIR specification
url 1..1 uri URL to the specification description 0..1 string Short description capability 1..* BackboneElement Capabilities that are assumed to function correctly on the FHIR server being tested
required 0..1 boolean Are the capabilities required? validated 0..1 boolean Are the capabilities validated? description 0..1 string The expected capabilities of the server origin 0..* integer Which origin server these requirements apply to
destination 0..1 integer Which server these requirements apply to link 0..* uri Links to the FHIR specification
capabilities 1..1 Reference(CapabilityStatement) Required Capability Statement fixture 0..* BackboneElement Fixture in the test script - by reference (uri)
autocreate 0..1 boolean Whether or not to implicitly create the fixture during setup autodelete 0..1 boolean Whether or not to implicitly delete the fixture during teardown resource 0..1 Reference(Any) Reference of the resource profile 0..* Reference(Any) Reference of the validation profile
variable I 0..* BackboneElement Placeholder for evaluated elements
+ Variable can only contain one of expression, headerField or path.
name 1..1 string Descriptive name for this variable defaultValue 0..1 string Default, hard-coded, or user-defined value for this variable description 0..1 string Natural language description of the variable expression 0..1 string The fluentpath expression against the fixture body headerField 0..1 string HTTP header field name for source hint 0..1 string Hint help text for default value to enter path 0..1 string XPath or JSONPath against the fixture body sourceId 0..1 id Fixture Id of source expression or headerField within this variable rule 0..* BackboneElement Assert rule used within the test script
resource 1..1 Reference(Any) Assert rule resource reference param 0..* BackboneElement Rule parameter template
name 1..1 string Parameter name matching external assert rule parameter value 0..1 string Parameter value defined either explicitly or dynamically ruleset 0..* BackboneElement Assert ruleset used within the test script
resource 1..1 Reference(Any) Assert ruleset resource reference rule 1..* BackboneElement The referenced rule within the ruleset
ruleId 1..1 id Id of referenced rule within the ruleset param 0..* BackboneElement Ruleset rule parameter template
name 1..1 string Parameter name matching external assert ruleset rule parameter value 0..1 string Parameter value defined either explicitly or dynamically setup 0..1 BackboneElement A series of required setup operations before tests are executed action I 1..* BackboneElement A setup operation or assert to perform
+ Setup action SHALL contain either an operation or assert but not both.
operation I 0..1 BackboneElement The setup operation to perform
+ Setup operation SHALL contain either sourceId or targetId or params or url. type 0..1 Coding The operation code type that will be executed
TestScriptOperationCode (Extensible) resource 0..1 code Resource type
FHIRDefinedType (Required) label 0..1 string Tracking/logging operation label description 0..1 string Tracking/reporting operation description accept 0..1 code xml | json | ttl | none
ContentType (Required) contentType 0..1 code xml | json | ttl | none
ContentType (Required) destination 0..1 integer Server responding to the request encodeRequestUrl 0..1 boolean Whether or not to send the request url in encoded format origin 0..1 integer Server initiating the request params 0..1 string Explicitly defined path parameters requestHeader 0..* BackboneElement Each operation can have one or more header elements
field 1..1 string HTTP header field name value 1..1 string HTTP headerfield value requestId 0..1 id Fixture Id of mapped request responseId 0..1 id Fixture Id of mapped response sourceId 0..1 id Fixture Id of body for PUT and POST requests targetId 0..1 id Id of fixture used for extracting the [id], [type], and [vid] for GET requests url 0..1 string Request URL assert I 0..1 BackboneElement The assertion to perform
+ Only a single assertion SHALL be present within setup action assert element.
+ Setup action assert SHALL contain either compareToSourceId and compareToSourceExpression, compareToSourceId and compareToSourcePath or neither.
+ Setup action assert response and responseCode SHALL be empty when direction equals request label 0..1 string Tracking/logging assertion label description 0..1 string Tracking/reporting assertion description direction 0..1 code response | request
AssertionDirectionType (Required) compareToSourceId 0..1 string Id of the source fixture to be evaluated compareToSourceExpression 0..1 string The fluentpath expression to evaluate against the source fixture compareToSourcePath 0..1 string XPath or JSONPath expression to evaluate against the source fixture contentType 0..1 code xml | json | ttl | none
ContentType (Required) expression 0..1 string The fluentpath expression to be evaluated headerField 0..1 string HTTP header field name minimumId 0..1 string Fixture Id of minimum content resource navigationLinks 0..1 boolean Perform validation on navigation links? operator 0..1 code equals | notEquals | in | notIn | greaterThan | lessThan | empty | notEmpty | contains | notContains | eval
AssertionOperatorType (Required) path 0..1 string XPath or JSONPath expression requestMethod 0..1 code delete | get | options | patch | post | put
TestScriptRequestMethodCode (Required) requestURL 0..1 string Request URL comparison value resource 0..1 code Resource type
FHIRDefinedType (Required) response 0..1 code okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable
AssertionResponseTypes (Required) responseCode 0..1 string HTTP response code to test rule 0..1 BackboneElement The reference to a TestScript.rule ruleId 1..1 id Id of the TestScript.rule param 0..* BackboneElement Rule parameter template
name 1..1 string Parameter name matching external assert rule parameter value 1..1 string Parameter value defined either explicitly or dynamically ruleset 0..1 BackboneElement The reference to a TestScript.ruleset rulesetId 1..1 id Id of the TestScript.ruleset rule 0..* BackboneElement The referenced rule within the ruleset
ruleId 1..1 id Id of referenced rule within the ruleset param 0..* BackboneElement Rule parameter template
name 1..1 string Parameter name matching external assert ruleset rule parameter value 1..1 string Parameter value defined either explicitly or dynamically sourceId 0..1 id Fixture Id of source expression or headerField validateProfileId 0..1 id Profile Id of validation profile reference value 0..1 string The value to compare to warningOnly 0..1 boolean Will this assert produce a warning only on error? test 0..* BackboneElement A test in this script
name 0..1 string Tracking/logging name of this test description 0..1 string Tracking/reporting short description of the test action I 1..* BackboneElement A test operation or assert to perform
+ Test action SHALL contain either an operation or assert but not both.
operation I 0..1 see operation The setup operation to perform
+ Test operation SHALL contain either sourceId or targetId or params or url. assert I 0..1 see assert The setup assertion to perform
+ Only a single assertion SHALL be present within test action assert element.
+ Test action assert SHALL contain either compareToSourceId and compareToSourceExpression, compareToSourceId and compareToSourcePath or neither.
+ Test action assert response and response and responseCode SHALL be empty when direction equals request teardown 0..1 BackboneElement A series of required clean up steps action 1..* BackboneElement One or more teardown operations to perform
operation I 1..1 see operation The teardown operation to perform
+ Teardown operation SHALL contain either sourceId or targetId or params or url.
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 2
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/TestScript",
"name": "TestScript",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for TestScript Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "objimpl",
"uri": "http://hl7.org/fhir/object-implementation",
"name": "Object Implementation Information"
}
],
"kind": "resource",
"abstract": false,
"type": "TestScript",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"_baseDefinition": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-codegen-super",
"valueString": "MetadataResource"
}
]
},
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "TestScript",
"path": "TestScript",
"short": "Describes a set of tests",
"definition": "A structured set of tests against a FHIR server implementation to determine compliance against the FHIR specification.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "conformance.misc"
}
]
},
{
"id": "TestScript.id",
"path": "TestScript.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "TestScript.meta",
"path": "TestScript.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "TestScript.implicitRules",
"path": "TestScript.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "TestScript.language",
"path": "TestScript.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "TestScript.text",
"path": "TestScript.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "TestScript.contained",
"path": "TestScript.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.extension",
"path": "TestScript.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.modifierExtension",
"path": "TestScript.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.url",
"path": "TestScript.url",
"short": "Logical URI to reference this test script (globally unique)",
"definition": "An absolute URI that is used to identify this test script when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this test script is (or will be) published. The URL SHOULD include the major version of the test script. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the test script to be referenced by a single globally unique identifier.",
"alias": [
"url",
"authoritative-url",
"destination",
"identity"
],
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "TestScript.identifier",
"path": "TestScript.identifier",
"short": "Additional identifier for the test script",
"definition": "A formal identifier that is used to identify this test script when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this test script outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "TestScript.version",
"path": "TestScript.version",
"short": "Business version of the test script",
"definition": "The identifier that is used to identify this version of the test script when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the test script author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different test script instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the test script with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "TestScript.name",
"path": "TestScript.name",
"short": "Name for this test script (computer friendly)",
"definition": "A natural language name identifying the test script. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "TestScript.title",
"path": "TestScript.title",
"short": "Name for this test script (human friendly)",
"definition": "A short, descriptive, user-friendly title for the test script.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "TestScript.status",
"path": "TestScript.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this test script. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of test scripts that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired test script without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "TestScript.experimental",
"path": "TestScript.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this test script is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of test script that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental test script in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level test script.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "TestScript.date",
"path": "TestScript.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the test script was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the test script changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the test script. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "TestScript.publisher",
"path": "TestScript.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the test script.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the test script is the organization or individual primarily responsible for the maintenance and upkeep of the test script. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the test script. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the test script. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "TestScript.contact",
"path": "TestScript.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "TestScript.description",
"path": "TestScript.description",
"short": "Natural language description of the test script",
"definition": "A free text natural language description of the test script from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the test script was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the test script as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "TestScript.useContext",
"path": "TestScript.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate test script instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "TestScript.jurisdiction",
"path": "TestScript.jurisdiction",
"short": "Intended jurisdiction for test script (if applicable)",
"definition": "A legal or geographic region in which the test script is intended to be used.",
"comment": "It may be possible for the test script to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "TestScript.purpose",
"path": "TestScript.purpose",
"short": "Why this test script is defined",
"definition": "Explaination of why this test script is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the test script Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this test script.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "TestScript.copyright",
"path": "TestScript.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the test script and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the test script.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the test script and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "TestScript.origin",
"path": "TestScript.origin",
"short": "An abstract server representing a client or sender in a message exchange",
"definition": "An abstract server used in operations within this test script in the origin element.",
"comment": "The purpose of this element is to define the profile of an origin element used elsewhere in the script. Test engines could then use the origin-profile mapping to offer a filtered list of test systems that can serve as the sender for the interaction.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.origin.id",
"path": "TestScript.origin.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.origin.extension",
"path": "TestScript.origin.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.origin.modifierExtension",
"path": "TestScript.origin.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.origin.index",
"path": "TestScript.origin.index",
"short": "The index of the abstract origin server starting at 1",
"definition": "Abstract name given to an origin server in this test script. The name is provided as a number starting at 1.",
"comment": "A given origin index (e.g. 1) can appear only once in the list (e.g. Origin 1 cannot be specified twice ... once as FormFiller and and again as FormProcessor within the same script as that could get confusing during test configuration). \n\nDifferent origin indices could play the same actor in the same test script (e.g. You could have two different test systems acting as Form-Filler).\n\nThe origin indices provided elsewhere in the test script must be one of these origin indices.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.origin.profile",
"path": "TestScript.origin.profile",
"short": "FHIR-Client | FHIR-SDC-FormFiller",
"definition": "The type of origin profile the test system supports.",
"comment": "Must be a \"sender\"/\"client\" profile.",
"min": 1,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"meaningWhenMissing": "FHIR-Client",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestScriptProfileOriginType"
}
],
"strength": "extensible",
"description": "The type of origin profile the test system supports.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/testscript-profile-origin-types"
}
}
},
{
"id": "TestScript.destination",
"path": "TestScript.destination",
"short": "An abstract server representing a destination or receiver in a message exchange",
"definition": "An abstract server used in operations within this test script in the destination element.",
"comment": "The purpose of this element is to define the profile of a destination element used elsewhere in the script. Test engines could then use the destination-profile mapping to offer a filtered list of test systems that can serve as the receiver for the interaction.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.destination.id",
"path": "TestScript.destination.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.destination.extension",
"path": "TestScript.destination.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.destination.modifierExtension",
"path": "TestScript.destination.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.destination.index",
"path": "TestScript.destination.index",
"short": "The index of the abstract destination server starting at 1",
"definition": "Abstract name given to a destination server in this test script. The name is provided as a number starting at 1.",
"comment": "A given destination index (e.g. 1) can appear only once in the list (e.g. Destination 1 cannot be specified twice ... once as Form-Manager and again as Form-Processor within the same script as that could get confusing during test configuration). \n\nDifferent destination indices could play the same actor in the same test script (e.g. You could have two different test systems acting as Form-Manager).\n\nThe destination indices provided elsewhere in the test script must be one of these destination indices.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.destination.profile",
"path": "TestScript.destination.profile",
"short": "FHIR-Server | FHIR-SDC-FormManager | FHIR-SDC-FormReceiver | FHIR-SDC-FormProcessor",
"definition": "The type of destination profile the test system supports.",
"comment": "Must be a \"receiver\"/\"server\" profile.",
"min": 1,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"meaningWhenMissing": "FHIR-Server",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestScriptProfileDestinationType"
}
],
"strength": "extensible",
"description": "The type of destination profile the test system supports.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/testscript-profile-destination-types"
}
}
},
{
"id": "TestScript.metadata",
"path": "TestScript.metadata",
"short": "Required capability that is assumed to function correctly on the FHIR server being tested",
"definition": "The required capability must exist and are assumed to function correctly on the FHIR server being tested.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "inv-4",
"severity": "error",
"human": "TestScript metadata capability SHALL contain required or validated or both.",
"expression": "capability.required.exists() or capability.validated.exists()",
"xpath": "f:capability/f:required or f:capability/f:validated or (f:capability/f:required and f:capability/f:validated)"
}
]
},
{
"id": "TestScript.metadata.id",
"path": "TestScript.metadata.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.metadata.extension",
"path": "TestScript.metadata.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.metadata.modifierExtension",
"path": "TestScript.metadata.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.metadata.link",
"path": "TestScript.metadata.link",
"short": "Links to the FHIR specification",
"definition": "A link to the FHIR specification that this test is covering.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.metadata.link.id",
"path": "TestScript.metadata.link.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.metadata.link.extension",
"path": "TestScript.metadata.link.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.metadata.link.modifierExtension",
"path": "TestScript.metadata.link.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.metadata.link.url",
"path": "TestScript.metadata.link.url",
"short": "URL to the specification",
"definition": "URL to a particular requirement or feature within the FHIR specification.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "TestScript.metadata.link.description",
"path": "TestScript.metadata.link.description",
"short": "Short description",
"definition": "Short description of the link.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.metadata.capability",
"path": "TestScript.metadata.capability",
"short": "Capabilities that are assumed to function correctly on the FHIR server being tested",
"definition": "Capabilities that must exist and are assumed to function correctly on the FHIR server being tested.",
"comment": "When the metadata capabilities section is defined at TestScript.metadata or at TestScript.setup.metadata, and the server's conformance statement does not contain the elements defined in the minimal conformance statement, then all the tests in the TestScript are skipped. When the metadata capabilities section is defined at TestScript.test.metadata and the server's conformance statement does not contain the elements defined in the minimal conformance statement, then only that test is skipped. The \"metadata.capabilities.required\" and \"metadata.capabilities.validated\" elements only indicate whether the capabilities are the primary focus of the test script or not. They do not impact the skipping logic. Capabilities whose \"metadata.capabilities.validated\" flag is true are the primary focus of the test script.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.metadata.capability.id",
"path": "TestScript.metadata.capability.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.metadata.capability.extension",
"path": "TestScript.metadata.capability.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.metadata.capability.modifierExtension",
"path": "TestScript.metadata.capability.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.metadata.capability.required",
"path": "TestScript.metadata.capability.required",
"short": "Are the capabilities required?",
"definition": "Whether or not the test execution will require the given capabilities of the server in order for this test script to execute.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "TestScript.metadata.capability.validated",
"path": "TestScript.metadata.capability.validated",
"short": "Are the capabilities validated?",
"definition": "Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "TestScript.metadata.capability.description",
"path": "TestScript.metadata.capability.description",
"short": "The expected capabilities of the server",
"definition": "Description of the capabilities that this test script is requiring the server to support.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.metadata.capability.origin",
"path": "TestScript.metadata.capability.origin",
"short": "Which origin server these requirements apply to",
"definition": "Which origin server these requirements apply to.",
"min": 0,
"max": "*",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.metadata.capability.destination",
"path": "TestScript.metadata.capability.destination",
"short": "Which server these requirements apply to",
"definition": "Which server these requirements apply to.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.metadata.capability.link",
"path": "TestScript.metadata.capability.link",
"short": "Links to the FHIR specification",
"definition": "Links to the FHIR specification that describes this interaction and the resources involved in more detail.",
"min": 0,
"max": "*",
"type": [
{
"code": "uri"
}
]
},
{
"id": "TestScript.metadata.capability.capabilities",
"path": "TestScript.metadata.capability.capabilities",
"short": "Required Capability Statement",
"definition": "Minimum capabilities required of server for test script to execute successfully. If server does not meet at a minimum the referenced capability statement, then all tests in this script are skipped.",
"comment": "The conformance statement of the server has to contain at a minimum the contents of the reference pointed to by this element.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CapabilityStatement"
}
]
},
{
"id": "TestScript.fixture",
"path": "TestScript.fixture",
"short": "Fixture in the test script - by reference (uri)",
"definition": "Fixture in the test script - by reference (uri). All fixtures are required for the test script to execute.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.fixture.id",
"path": "TestScript.fixture.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.fixture.extension",
"path": "TestScript.fixture.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.fixture.modifierExtension",
"path": "TestScript.fixture.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.fixture.autocreate",
"path": "TestScript.fixture.autocreate",
"short": "Whether or not to implicitly create the fixture during setup",
"definition": "Whether or not to implicitly create the fixture during setup. If true, the fixture is automatically created on each server being tested during setup, therefore no create operation is required for this fixture in the TestScript.setup section.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "TestScript.fixture.autodelete",
"path": "TestScript.fixture.autodelete",
"short": "Whether or not to implicitly delete the fixture during teardown",
"definition": "Whether or not to implicitly delete the fixture during teardown. If true, the fixture is automatically deleted on each server being tested during teardown, therefore no delete operation is required for this fixture in the TestScript.teardown section.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "TestScript.fixture.resource",
"path": "TestScript.fixture.resource",
"short": "Reference of the resource",
"definition": "Reference to the resource (containing the contents of the resource needed for operations).",
"comment": "See http://build.fhir.org/resourcelist.html for complete list of resource types.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "TestScript.profile",
"path": "TestScript.profile",
"short": "Reference of the validation profile",
"definition": "Reference to the profile to be used for validation.",
"comment": "See http://build.fhir.org/resourcelist.html for complete list of resource types.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "TestScript.variable",
"path": "TestScript.variable",
"short": "Placeholder for evaluated elements",
"definition": "Variable is set based either on element value in response body or on header field value in the response headers.",
"comment": "Variables would be set based either on XPath/JSONPath expressions against fixtures (static and response), or headerField evaluations against response headers. If variable evaluates to nodelist or anything other than a primitive value, then test engine would report an error. Variables would be used to perform clean replacements in \"operation.params\", \"operation.requestHeader.value\", and \"operation.url\" element values during operation calls and in \"assert.value\" during assertion evaluations. This limits the places that test engines would need to look for placeholders \"${}\". Variables are scoped to the whole script. They are NOT evaluated at declaration. They are evaluated by test engine when used for substitutions in \"operation.params\", \"operation.requestHeader.value\", and \"operation.url\" element values during operation calls and in \"assert.value\" during assertion evaluations. See example testscript-search.xml.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "inv-3",
"severity": "error",
"human": "Variable can only contain one of expression, headerField or path.",
"expression": "expression.empty() or headerField.empty() or path.empty()",
"xpath": "not(f:expression and f:headerField and f:path)"
}
]
},
{
"id": "TestScript.variable.id",
"path": "TestScript.variable.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.variable.extension",
"path": "TestScript.variable.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.variable.modifierExtension",
"path": "TestScript.variable.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.variable.name",
"path": "TestScript.variable.name",
"short": "Descriptive name for this variable",
"definition": "Descriptive name for this variable.",
"comment": "Placeholders would contain the variable name wrapped in ${} in \"operation.params\", \"operation.requestHeader.value\", and \"operation.url\" elements. These placeholders would need to be replaced by the variable value before the operation is executed.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.defaultValue",
"path": "TestScript.variable.defaultValue",
"short": "Default, hard-coded, or user-defined value for this variable",
"definition": "A default, hard-coded, or user-defined value for this variable.",
"comment": "The purpose of this element is to allow for a pre-defined value that can be used as a default or as an override value. Test engines can optionally use this as a placeholder for user-defined execution time values.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.description",
"path": "TestScript.variable.description",
"short": "Natural language description of the variable",
"definition": "A free text natural language description of the variable and its purpose.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.expression",
"path": "TestScript.variable.expression",
"short": "The fluentpath expression against the fixture body",
"definition": "The fluentpath expression to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.",
"comment": "If headerField is defined, then the variable will be evaluated against the headers that sourceId is pointing to. If expression or path is defined, then the variable will be evaluated against the fixture body that sourceId is pointing to. It is an error to define any combination of expression, headerField and path.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.headerField",
"path": "TestScript.variable.headerField",
"short": "HTTP header field name for source",
"definition": "Will be used to grab the HTTP header field value from the headers that sourceId is pointing to.",
"comment": "If headerField is defined, then the variable will be evaluated against the headers that sourceId is pointing to. If path is defined, then the variable will be evaluated against the fixture body that sourceId is pointing to. It is an error to define both headerField and path.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.hint",
"path": "TestScript.variable.hint",
"short": "Hint help text for default value to enter",
"definition": "Displayable text string with hint help information to the user when entering a default value.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.path",
"path": "TestScript.variable.path",
"short": "XPath or JSONPath against the fixture body",
"definition": "XPath or JSONPath to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.",
"comment": "If headerField is defined, then the variable will be evaluated against the headers that sourceId is pointing to. If expression or path is defined, then the variable will be evaluated against the fixture body that sourceId is pointing to. It is an error to define any combination of expression, headerField and path.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.sourceId",
"path": "TestScript.variable.sourceId",
"short": "Fixture Id of source expression or headerField within this variable",
"definition": "Fixture to evaluate the XPath/JSONPath expression or the headerField against within this variable.",
"comment": "This can be a statically defined fixture (at the top of the TestScript) or a dynamically set fixture created by responseId of the `action.operation` element.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.rule",
"path": "TestScript.rule",
"short": "Assert rule used within the test script",
"definition": "Assert rule to be used in one or more asserts within the test script.",
"comment": "Each rule should be treated by test engines as one assertion regardless of how many assertions are contained within the external rule template. The impact of negative rule evaluation on test script execution is the same as an assertion failure which is described elsewhere in the TestScript resource.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.rule.id",
"path": "TestScript.rule.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.rule.extension",
"path": "TestScript.rule.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.rule.modifierExtension",
"path": "TestScript.rule.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.rule.resource",
"path": "TestScript.rule.resource",
"short": "Assert rule resource reference",
"definition": "Reference to the resource (containing the contents of the rule needed for assertions).",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "TestScript.rule.param",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "RuleParam"
}
],
"path": "TestScript.rule.param",
"short": "Rule parameter template",
"definition": "Each rule template can take one or more parameters for rule evaluation.",
"comment": "The parameter value can be dynamic at runtime.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.rule.param.id",
"path": "TestScript.rule.param.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.rule.param.extension",
"path": "TestScript.rule.param.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.rule.param.modifierExtension",
"path": "TestScript.rule.param.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.rule.param.name",
"path": "TestScript.rule.param.name",
"short": "Parameter name matching external assert rule parameter",
"definition": "Descriptive name for this parameter that matches the external assert rule parameter name.",
"comment": "The external rule template would be looking for the parameter by this name.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.rule.param.value",
"path": "TestScript.rule.param.value",
"short": "Parameter value defined either explicitly or dynamically",
"definition": "The explicit or dynamic value for the parameter that will be passed on to the external rule template.",
"comment": "This value can be overwritten by the assert.rule.param.value i.e. TestScript.rule.param.value will be used if assert.rule.param.value is not specified. The param value can be a string-representation of a number, string, or boolean that is expected. Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before supplying this value to the external rule template.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.ruleset",
"path": "TestScript.ruleset",
"short": "Assert ruleset used within the test script",
"definition": "Contains one or more rules. Offers a way to group rules so assertions could reference the group of rules and have them all applied.",
"comment": "Each rule within a ruleset should be treated by test engines as one assertion regardless of how many assertions are contained within the external rule template. The impact of negative rule evaluation on test script execution is the same as an assertion failure which is described elsewhere in the TestScript resource.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.ruleset.id",
"path": "TestScript.ruleset.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.ruleset.extension",
"path": "TestScript.ruleset.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.ruleset.modifierExtension",
"path": "TestScript.ruleset.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.ruleset.resource",
"path": "TestScript.ruleset.resource",
"short": "Assert ruleset resource reference",
"definition": "Reference to the resource (containing the contents of the ruleset needed for assertions).",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "TestScript.ruleset.rule",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "RulesetRule"
}
],
"path": "TestScript.ruleset.rule",
"short": "The referenced rule within the ruleset",
"definition": "The referenced rule within the external ruleset template.",
"comment": "This qualifies each param name so that a parameter with the same name can be used differently by the different rules with the ruleset.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.ruleset.rule.id",
"path": "TestScript.ruleset.rule.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.ruleset.rule.extension",
"path": "TestScript.ruleset.rule.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.ruleset.rule.modifierExtension",
"path": "TestScript.ruleset.rule.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.ruleset.rule.ruleId",
"path": "TestScript.ruleset.rule.ruleId",
"short": "Id of referenced rule within the ruleset",
"definition": "Id of the referenced rule within the external ruleset template.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.ruleset.rule.param",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "RulesetRuleParam"
}
],
"path": "TestScript.ruleset.rule.param",
"short": "Ruleset rule parameter template",
"definition": "Each rule template can take one or more parameters for rule evaluation.",
"comment": "The parameter value can be dynamic at runtime.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.ruleset.rule.param.id",
"path": "TestScript.ruleset.rule.param.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.ruleset.rule.param.extension",
"path": "TestScript.ruleset.rule.param.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.ruleset.rule.param.modifierExtension",
"path": "TestScript.ruleset.rule.param.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.ruleset.rule.param.name",
"path": "TestScript.ruleset.rule.param.name",
"short": "Parameter name matching external assert ruleset rule parameter",
"definition": "Descriptive name for this parameter that matches the external assert ruleset rule parameter name.",
"comment": "The external rule template would be looking for the parameter by this name.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.ruleset.rule.param.value",
"path": "TestScript.ruleset.rule.param.value",
"short": "Parameter value defined either explicitly or dynamically",
"definition": "The value for the parameter that will be passed on to the external ruleset rule template.",
"comment": "This value can be overwritten by the assert.ruleset.rule.param.value i.e. TestScript.ruleset.rule.param.value will be used if assert.ruleset.rule.param.value is not specified. The param value can be a string-representation of a number, string, or boolean that is expected. Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before supplying this value to the external rule template.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup",
"path": "TestScript.setup",
"short": "A series of required setup operations before tests are executed",
"definition": "A series of required setup operations before tests are executed.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.setup.id",
"path": "TestScript.setup.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.extension",
"path": "TestScript.setup.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.modifierExtension",
"path": "TestScript.setup.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.setup.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "SetupAction"
}
],
"path": "TestScript.setup.action",
"short": "A setup operation or assert to perform",
"definition": "Action would contain either an operation or an assertion.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "inv-1",
"severity": "error",
"human": "Setup action SHALL contain either an operation or assert but not both.",
"expression": "operation.exists() xor assert.exists()",
"xpath": "(f:operation or f:assert) and not(f:operation and f:assert)"
}
]
},
{
"id": "TestScript.setup.action.id",
"path": "TestScript.setup.action.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.extension",
"path": "TestScript.setup.action.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.modifierExtension",
"path": "TestScript.setup.action.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.setup.action.operation",
"path": "TestScript.setup.action.operation",
"short": "The setup operation to perform",
"definition": "The operation to perform.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "inv-7",
"severity": "error",
"human": "Setup operation SHALL contain either sourceId or targetId or params or url.",
"expression": "sourceId.exists() or (targetId.count() + url.count() + params.count() = 1) or (type.code in ('capabilities' |'search' | 'transaction' | 'history'))",
"xpath": "f:sourceId or ((f:targetId or f:url or f:params) and (count(f:targetId) + count(f:url) + count(f:params) =1)) or (f:type/f:code/@value='capabilities' or f:type/f:code/@value='search' or f:type/f:code/@value='transaction' or f:type/f:code/@value='history')"
}
]
},
{
"id": "TestScript.setup.action.operation.id",
"path": "TestScript.setup.action.operation.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.operation.extension",
"path": "TestScript.setup.action.operation.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.operation.modifierExtension",
"path": "TestScript.setup.action.operation.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.setup.action.operation.type",
"path": "TestScript.setup.action.operation.type",
"short": "The operation code type that will be executed",
"definition": "Server interaction or operation type.",
"comment": "See http://build.fhir.org/http.html for list of server interactions.",
"min": 0,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestScriptOperationCode"
}
],
"strength": "extensible",
"description": "The allowable operation code types.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/testscript-operation-codes"
}
}
},
{
"id": "TestScript.setup.action.operation.resource",
"path": "TestScript.setup.action.operation.resource",
"short": "Resource type",
"definition": "The type of the resource. See http://build.fhir.org/resourcelist.html.",
"comment": "If \"url\" element is specified, then \"targetId\", \"params\", and \"resource\" elements will be ignored as \"url\" element will have everything needed for constructing the request url. If \"params\" element is specified, then \"targetId\" element is ignored. For FHIR operations that require a resource (e.g. \"read\" and \"vread\" operations), the \"resource\" element must be specified when \"params\" element is specified. If \"url\" and \"params\" elements are absent, then the request url will be constructed from \"targetId\" fixture if present. For \"read\" operation, the resource and id values will be extracted from \"targetId\" fixture and used to construct the url. For \"vread\" and \"history\" operations, the versionId value will also be used.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FHIRDefinedType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Either a resource or a data type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/defined-types"
}
}
},
{
"id": "TestScript.setup.action.operation.label",
"path": "TestScript.setup.action.operation.label",
"short": "Tracking/logging operation label",
"definition": "The label would be used for tracking/logging purposes by test engines.",
"comment": "This has no impact on the verification itself.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.operation.description",
"path": "TestScript.setup.action.operation.description",
"short": "Tracking/reporting operation description",
"definition": "The description would be used by test engines for tracking and reporting purposes.",
"comment": "This has no impact on the verification itself.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.operation.accept",
"path": "TestScript.setup.action.operation.accept",
"short": "xml | json | ttl | none",
"definition": "The content-type or mime-type to use for RESTful operation in the 'Accept' header.",
"comment": "If this is specified, then test engine shall set the 'Accept' header to the corresponding value. If 'xml' is specified, then 'Accept' header of 'application/fhir+xml' will be set. If 'json' is specified, then 'application/fhir+json' will be used. If you'd like to explicitly set the 'Accept' to some other value then use the 'requestHeader' element.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "xml",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ContentType"
}
],
"strength": "required",
"description": "The content or mime type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/content-type"
}
}
},
{
"id": "TestScript.setup.action.operation.contentType",
"path": "TestScript.setup.action.operation.contentType",
"short": "xml | json | ttl | none",
"definition": "The content-type or mime-type to use for RESTful operation in the 'Content-Type' header.",
"comment": "If this is specified, then test engine shall set the 'Content-Type' header to the corresponding value. If 'xml' is specified, then 'Content-Type' header of 'application/fhir+xml' will be set. If 'json' is specified, then 'application/fhir+json' will be used. If you'd like to explicitly set the 'Content-Type' to some other value then use the 'requestHeader' element.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "xml",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ContentType"
}
],
"strength": "required",
"description": "The content or mime type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/content-type"
}
}
},
{
"id": "TestScript.setup.action.operation.destination",
"path": "TestScript.setup.action.operation.destination",
"short": "Server responding to the request",
"definition": "The server where the request message is destined for. Must be one of the server numbers listed in TestScript.destination section.",
"comment": "If multiple TestScript.destination elements are defined and operation.destination is undefined, test engine will report an error as it cannot determine what destination to use for the exchange.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.setup.action.operation.encodeRequestUrl",
"path": "TestScript.setup.action.operation.encodeRequestUrl",
"short": "Whether or not to send the request url in encoded format",
"definition": "Whether or not to implicitly send the request url in encoded format. The default is true to match the standard RESTful client behavior. Set to false when communicating with a server that does not support encoded url paths.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true
},
{
"id": "TestScript.setup.action.operation.origin",
"path": "TestScript.setup.action.operation.origin",
"short": "Server initiating the request",
"definition": "The server where the request message originates from. Must be one of the server numbers listed in TestScript.origin section.",
"comment": "If absent, test engine will send the message. When present, test engine will not send the request message but will wait for the request message to be sent from this origin server.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.setup.action.operation.params",
"path": "TestScript.setup.action.operation.params",
"short": "Explicitly defined path parameters",
"definition": "Path plus parameters after [type]. Used to set parts of the request URL explicitly.",
"comment": "If \"url\" element is specified, then \"targetId\", \"params\", and \"resource\" elements will be ignored as \"url\" element will have everything needed for constructing the request url. If \"params\" element is specified, then \"targetId\" element is ignored. For FHIR operations that require a resource (e.g. \"read\" and \"vread\" operations), the \"resource\" element must be specified when \"params\" element is specified. If \"url\" and \"params\" elements are absent, then the request url will be constructed from \"targetId\" fixture if present. For \"read\" operation, the resource and id values will be extracted from \"targetId\" fixture and used to construct the url. For \"vread\" and \"history\" operations, the versionId value will also be used. Test engines would append whatever is specified for \"params\" to the URL after the resource type without tampering with the string (beyond encoding the URL for HTTP). The \"params\" element does not correspond exactly to \"search parameters\". Nor is it the \"path\". It corresponds to the part of the URL that comes after the [type] (when \"resource\" element is specified); e.g. It corresponds to \"/[id]/_history/[vid] {?_format=[mime-type]}\" in the following operation: GET [base]/[type]/[id]/_history/[vid] {?_format=[mime-type]} Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before sending the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.operation.requestHeader",
"path": "TestScript.setup.action.operation.requestHeader",
"short": "Each operation can have one or more header elements",
"definition": "Header elements would be used to set HTTP headers.",
"comment": "This gives control to test-script writers to set headers explicitly based on test requirements. It will allow for testing using: - \"If-Modified-Since\" and \"If-None-Match\" headers. See http://build.fhir.org/http.html#2.1.0.5.1 - \"If-Match\" header. See http://build.fhir.org/http.html#2.1.0.11 - Conditional Create using \"If-None-Exist\". See http://build.fhir.org/http.html#2.1.0.13.1 - Invalid \"Content-Type\" header for negative testing. - etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.setup.action.operation.requestHeader.id",
"path": "TestScript.setup.action.operation.requestHeader.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.operation.requestHeader.extension",
"path": "TestScript.setup.action.operation.requestHeader.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.operation.requestHeader.modifierExtension",
"path": "TestScript.setup.action.operation.requestHeader.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.setup.action.operation.requestHeader.field",
"path": "TestScript.setup.action.operation.requestHeader.field",
"short": "HTTP header field name",
"definition": "The HTTP header field e.g. \"Accept\".",
"comment": "If header element is specified, then field is required.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.operation.requestHeader.value",
"path": "TestScript.setup.action.operation.requestHeader.value",
"short": "HTTP headerfield value",
"definition": "The value of the header e.g. \"application/fhir+xml\".",
"comment": "If header element is specified, then value is required. No conversions will be done by the test engine e.g. \"xml\" to \"application/fhir+xml\". The values will be set in HTTP headers \"as-is\". Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before sending the request.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.operation.requestId",
"path": "TestScript.setup.action.operation.requestId",
"short": "Fixture Id of mapped request",
"definition": "The fixture id (maybe new) to map to the request.",
"comment": "If a requestId is supplied, then the resulting request (both headers and body) is mapped to the fixture ID (which may be entirely new and previously undeclared) designated by \"requestId\". If requestId is not specified, it is the test engine's responsibility to store the request and use it as the requestId in subsequent assertions when assertion path and/or headerField is specified, direction is equal to request, and the requestId in not specified.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.operation.responseId",
"path": "TestScript.setup.action.operation.responseId",
"short": "Fixture Id of mapped response",
"definition": "The fixture id (maybe new) to map to the response.",
"comment": "If a responseId is supplied, and the server responds, then the resulting response (both headers and body) is mapped to the fixture ID (which may be entirely new and previously undeclared) designated by \"responseId\". If responseId is not specified, it is the test engine's responsibility to store the response and use it as the responseId in subsequent assertions when assertion path and/or headerField is specified and the responseId is not specified.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.operation.sourceId",
"path": "TestScript.setup.action.operation.sourceId",
"short": "Fixture Id of body for PUT and POST requests",
"definition": "The id of the fixture used as the body of a PUT or POST request.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.operation.targetId",
"path": "TestScript.setup.action.operation.targetId",
"short": "Id of fixture used for extracting the [id], [type], and [vid] for GET requests",
"definition": "Id of fixture used for extracting the [id], [type], and [vid] for GET requests.",
"comment": "If \"url\" element is specified, then \"targetId\", \"params\", and \"resource\" elements will be ignored as \"url\" element will have everything needed for constructing the request url. If \"params\" element is specified, then \"targetId\" element is ignored. For FHIR operations that require a resource (e.g. \"read\" and \"vread\" operations), the \"resource\" element must be specified when \"params\" element is specified. If \"url\" and \"params\" elements are absent, then the request url will be constructed from \"targetId\" fixture if present. For \"read\" operation, the resource and id values will be extracted from \"targetId\" fixture and used to construct the url. For \"vread\" and \"history\" operations, the versionId value will also be used.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.operation.url",
"path": "TestScript.setup.action.operation.url",
"short": "Request URL",
"definition": "Complete request URL.",
"comment": "Used to set the request URL explicitly. If \"url\" element is defined, then \"targetId\", \"resource\", and \"params\" elements will be ignored. Test engines would use whatever is specified in \"url\" without tampering with the string (beyond encoding the URL for HTTP). Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before sending the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert",
"path": "TestScript.setup.action.assert",
"short": "The assertion to perform",
"definition": "Evaluates the results of previous operations to determine if the server under test behaves appropriately.",
"comment": "In order to evaluate an assertion, the request, response, and results of the most recently executed operation must always be maintained by the test engine.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "inv-5",
"severity": "error",
"human": "Only a single assertion SHALL be present within setup action assert element.",
"expression": "contentType.count() + expression.count() + headerField.count() + minimumId.count() + navigationLinks.count() + path.count() + requestMethod.count() + resource.count() + responseCode.count() + response.count() + rule.count() + ruleset.count() + validateProfileId.count() <=1",
"xpath": "count(f:contentType) + count(f:expression) + count(f:headerField) + count(f:minimumId) + count(f:navigationLinks) + count(f:path) + count(f:requestMethod) + count(f:resource) + count(f:responseCode) + count(f:response) + count(f:rule) + count(f:ruleset) + count(f:validateProfileId) <=1"
},
{
"key": "inv-10",
"severity": "error",
"human": "Setup action assert SHALL contain either compareToSourceId and compareToSourceExpression, compareToSourceId and compareToSourcePath or neither.",
"expression": "compareToSourceId.empty() xor (compareToSourceExpression.exists() or compareToSourcePath.exists())",
"xpath": "(f:compareToSourceId and f:compareToSourceExpression) or (f:compareToSourceId and f:compareToSourcePath) or not(f:compareToSourceId or f:compareToSourceExpression or f:compareToSourcePath)"
},
{
"key": "inv-12",
"severity": "error",
"human": "Setup action assert response and responseCode SHALL be empty when direction equals request",
"expression": "(response.empty() and responseCode.empty() and direction = 'request') or direction.empty() or direction = 'response'",
"xpath": "((count(f:response) + count(f:responseCode)) = 0 and (f:direction/@value='request')) or (count(f:direction) = 0) or (f:direction/@value='response')"
}
]
},
{
"id": "TestScript.setup.action.assert.id",
"path": "TestScript.setup.action.assert.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.extension",
"path": "TestScript.setup.action.assert.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.modifierExtension",
"path": "TestScript.setup.action.assert.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.setup.action.assert.label",
"path": "TestScript.setup.action.assert.label",
"short": "Tracking/logging assertion label",
"definition": "The label would be used for tracking/logging purposes by test engines.",
"comment": "This has no impact on the verification itself.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.description",
"path": "TestScript.setup.action.assert.description",
"short": "Tracking/reporting assertion description",
"definition": "The description would be used by test engines for tracking and reporting purposes.",
"comment": "This has no impact on the verification itself.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.direction",
"path": "TestScript.setup.action.assert.direction",
"short": "response | request",
"definition": "The direction to use for the assertion.",
"comment": "If the direction is specified as \"response\" (the default), then the processing of this assert is against the received response message. If the direction is specified as \"request\", then the processing of this assert is against the sent request message.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AssertionDirectionType"
}
],
"strength": "required",
"description": "The type of direction to use for assertion.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/assert-direction-codes"
}
}
},
{
"id": "TestScript.setup.action.assert.compareToSourceId",
"path": "TestScript.setup.action.assert.compareToSourceId",
"short": "Id of the source fixture to be evaluated",
"definition": "Id of the source fixture used as the contents to be evaluated by either the \"source/expression\" or \"sourceId/path\" definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.compareToSourceExpression",
"path": "TestScript.setup.action.assert.compareToSourceExpression",
"short": "The fluentpath expression to evaluate against the source fixture",
"definition": "The fluentpath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.",
"comment": "Thefhirpath expression to be evaluated against the expected fixture to compare to. Ignored if \"assert.value\" is used. The evaluation will be done before the assertion is evaluated.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.compareToSourcePath",
"path": "TestScript.setup.action.assert.compareToSourcePath",
"short": "XPath or JSONPath expression to evaluate against the source fixture",
"definition": "XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.",
"comment": "The XPath or JSONPath expression to be evaluated against the expected fixture to compare to. Ignored if \"assert.value\" is used. The evaluation will be done before the assertion is evaluated.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.contentType",
"path": "TestScript.setup.action.assert.contentType",
"short": "xml | json | ttl | none",
"definition": "The content-type or mime-type to use for RESTful operation in the 'Content-Type' header.",
"comment": "If this is specified, then test engine shall confirm that the content-type of the last operation's headers is set to this value. If \"assert.sourceId\" element is specified, then the evaluation will be done against the headers mapped to that sourceId (and not the last operation's headers). If 'xml' is specified, then 'Content-Type' header of 'application/fhir+xml' will be confirmed. If 'json' is specified, then 'application/fhir+json' will be used. If you'd like to have more control over the string, then use 'assert.headerField' instead.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "xml",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ContentType"
}
],
"strength": "required",
"description": "The content or mime type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/content-type"
}
}
},
{
"id": "TestScript.setup.action.assert.expression",
"path": "TestScript.setup.action.assert.expression",
"short": "The fluentpath expression to be evaluated",
"definition": "The fluentpath expression to be evaluated against the request or response message contents - HTTP headers and payload.",
"comment": "If both \"expression\" and a \"fixtureId\" are specified, then the expression will be evaluated against the request or response body mapped to the fixtureId. If \"expression\" is specified and a \"fixtureId\" is not, then the expression will be evaluated against the response body of the last operation. Test engines are to store the request and response body and headers of the last operation at all times for subsequent assertions.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.headerField",
"path": "TestScript.setup.action.assert.headerField",
"short": "HTTP header field name",
"definition": "The HTTP header field name e.g. 'Location'.",
"comment": "If \"headerField\" is specified then \"value\" must be specified. If \"sourceId\" is not specified, then \"headerField\" will be evaluated against the last operation's response headers. Test engines are to keep track of the last operation's response body and response headers.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.minimumId",
"path": "TestScript.setup.action.assert.minimumId",
"short": "Fixture Id of minimum content resource",
"definition": "The ID of a fixture. Asserts that the response contains at a minimum the fixture specified by minimumId.",
"comment": "Asserts that the response contains all the element/content in another fixture pointed to by minimumId. This can be a statically defined fixture or one that is dynamically set via responseId.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.navigationLinks",
"path": "TestScript.setup.action.assert.navigationLinks",
"short": "Perform validation on navigation links?",
"definition": "Whether or not the test execution performs validation on the bundle navigation links.",
"comment": "Asserts that the Bundle contains first, last, and next links.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
]
},
{
"id": "TestScript.setup.action.assert.operator",
"path": "TestScript.setup.action.assert.operator",
"short": "equals | notEquals | in | notIn | greaterThan | lessThan | empty | notEmpty | contains | notContains | eval",
"definition": "The operator type defines the conditional behavior of the assert. If not defined, the default is equals.",
"comment": "Operators are useful especially for negative testing. If operator is not specified, then the \"equals\" operator is assumed; e.g. .",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AssertionOperatorType"
}
],
"strength": "required",
"description": "The type of operator to use for assertion.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/assert-operator-codes"
}
}
},
{
"id": "TestScript.setup.action.assert.path",
"path": "TestScript.setup.action.assert.path",
"short": "XPath or JSONPath expression",
"definition": "The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.",
"comment": "If both \"path\" and a \"fixtureId\" are specified, then the path will be evaluated against the request or response body mapped to the fixtureId. If \"path\" is specified and a \"fixtureId\" is not, then the path will be evaluated against the response body of the last operation. Test engines are to store the request and response body and headers of the last operation at all times for subsequent assertions.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.requestMethod",
"path": "TestScript.setup.action.assert.requestMethod",
"short": "delete | get | options | patch | post | put",
"definition": "The request method or HTTP operation code to compare against that used by the client system under test.",
"comment": "If \"requestMethod\" is specified then it will be used in place of \"value\". The \"requestMethod\" will evaluate against the last operation's request HTTP operation.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestScriptRequestMethodCode"
}
],
"strength": "required",
"description": "The allowable request method or HTTP operation codes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/http-operations"
}
}
},
{
"id": "TestScript.setup.action.assert.requestURL",
"path": "TestScript.setup.action.assert.requestURL",
"short": "Request URL comparison value",
"definition": "The value to use in a comparison against the request URL path string.",
"comment": "If \"requestURL\" is specified then it will be used in place of \"value\". The \"requestURL\" will evaluate against the last operation's full request URL path string.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.resource",
"path": "TestScript.setup.action.assert.resource",
"short": "Resource type",
"definition": "The type of the resource. See http://build.fhir.org/resourcelist.html.",
"comment": "This will be expected resource type in response body e.g. in read, vread, search, etc. See http://build.fhir.org/resourcelist.html for complete list of resource types; e.g. .",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FHIRDefinedType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Either a resource or a data type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/defined-types"
}
}
},
{
"id": "TestScript.setup.action.assert.response",
"path": "TestScript.setup.action.assert.response",
"short": "okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable",
"definition": "okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable.",
"comment": "This is a shorter way of achieving similar verifications via \"assert.responseCode\". If you need more control, then use \"assert.responseCode\" e.g. .",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AssertionResponseTypes"
}
],
"strength": "required",
"description": "The type of response code to use for assertion.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/assert-response-code-types"
}
}
},
{
"id": "TestScript.setup.action.assert.responseCode",
"path": "TestScript.setup.action.assert.responseCode",
"short": "HTTP response code to test",
"definition": "The value of the HTTP response code to be tested.",
"comment": "To be used with \"operator\" attribute value. Asserts that the response code equals this value if \"operator\" is not specified. If the operator is \"in\" or \"notIn\" then the responseCode would be a comma-separated list of values e.g. \"200,201\". Otherwise, it's expected to be a numeric value. If \"fixture\" is not specified, then the \"responseBodyId\" value of the last operation is assumed.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.rule",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ActionAssertRule"
}
],
"path": "TestScript.setup.action.assert.rule",
"short": "The reference to a TestScript.rule",
"definition": "The TestScript.rule this assert will evaluate.",
"comment": "Each rule should get evaluated by test engines as one assertion regardless of how many assertions are contained within the external rule template. The impact of negative rule evaluation on test script execution is the same as an assertion failure which is descibed elsewhere in the TestScript resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.id",
"path": "TestScript.setup.action.assert.rule.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.extension",
"path": "TestScript.setup.action.assert.rule.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.modifierExtension",
"path": "TestScript.setup.action.assert.rule.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.ruleId",
"path": "TestScript.setup.action.assert.rule.ruleId",
"short": "Id of the TestScript.rule",
"definition": "The TestScript.rule id value this assert will evaluate.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.param",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ActionAssertRuleParam"
}
],
"path": "TestScript.setup.action.assert.rule.param",
"short": "Rule parameter template",
"definition": "Each rule template can take one or more parameters for rule evaluation.",
"comment": "The parameter value can be dynamic at runtime.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.param.id",
"path": "TestScript.setup.action.assert.rule.param.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.param.extension",
"path": "TestScript.setup.action.assert.rule.param.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.param.modifierExtension",
"path": "TestScript.setup.action.assert.rule.param.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.param.name",
"path": "TestScript.setup.action.assert.rule.param.name",
"short": "Parameter name matching external assert rule parameter",
"definition": "Descriptive name for this parameter that matches the external assert rule parameter name.",
"comment": "The external rule template would be looking for the parameter by this name.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.param.value",
"path": "TestScript.setup.action.assert.rule.param.value",
"short": "Parameter value defined either explicitly or dynamically",
"definition": "The value for the parameter that will be passed on to the external rule template.",
"comment": "This value overwrites the value (if any) specified in TestScript.rule.param.value. The param value can be a string-representation of a number, string, or boolean that is expected. Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before supplying this value to the external rule template.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ActionAssertRuleset"
}
],
"path": "TestScript.setup.action.assert.ruleset",
"short": "The reference to a TestScript.ruleset",
"definition": "The TestScript.ruleset this assert will evaluate.",
"comment": "Each rule within a ruleset should get evaluated by test engines as a separate assertion. The impact of negative rule evaluation on test script execution is the same as an assertion failure which is descibed elsewhere in the TestScript resource. If the first rule within the ruleset results in a failed assertion, then test engines do not have to evaluate the rest of the rules within the ruleset.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.id",
"path": "TestScript.setup.action.assert.ruleset.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.extension",
"path": "TestScript.setup.action.assert.ruleset.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.modifierExtension",
"path": "TestScript.setup.action.assert.ruleset.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rulesetId",
"path": "TestScript.setup.action.assert.ruleset.rulesetId",
"short": "Id of the TestScript.ruleset",
"definition": "The TestScript.ruleset id value this assert will evaluate.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ActionAssertRulesetRule"
}
],
"path": "TestScript.setup.action.assert.ruleset.rule",
"short": "The referenced rule within the ruleset",
"definition": "The referenced rule within the external ruleset template.",
"comment": "This qualifies each param name so that a parameter with the same name can be used differently by the different rules with the ruleset.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.id",
"path": "TestScript.setup.action.assert.ruleset.rule.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.extension",
"path": "TestScript.setup.action.assert.ruleset.rule.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.modifierExtension",
"path": "TestScript.setup.action.assert.ruleset.rule.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.ruleId",
"path": "TestScript.setup.action.assert.ruleset.rule.ruleId",
"short": "Id of referenced rule within the ruleset",
"definition": "Id of the referenced rule within the external ruleset template.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.param",
"path": "TestScript.setup.action.assert.ruleset.rule.param",
"short": "Rule parameter template",
"definition": "Each rule template can take one or more parameters for rule evaluation.",
"comment": "The parameter value can be dynamic at runtime.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.param.id",
"path": "TestScript.setup.action.assert.ruleset.rule.param.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.param.extension",
"path": "TestScript.setup.action.assert.ruleset.rule.param.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.param.modifierExtension",
"path": "TestScript.setup.action.assert.ruleset.rule.param.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.param.name",
"path": "TestScript.setup.action.assert.ruleset.rule.param.name",
"short": "Parameter name matching external assert ruleset rule parameter",
"definition": "Descriptive name for this parameter that matches the external assert ruleset rule parameter name.",
"comment": "The external rule template would be looking for the parameter by this name.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.param.value",
"path": "TestScript.setup.action.assert.ruleset.rule.param.value",
"short": "Parameter value defined either explicitly or dynamically",
"definition": "The value for the parameter that will be passed on to the external ruleset rule template.",
"comment": "This value overwrites the value (if any) specified in TestScript.ruleset.rule.param.value. The param value can be a string-representation of a number, string, or boolean that is expected. Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before supplying this value to the external rule template.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.sourceId",
"path": "TestScript.setup.action.assert.sourceId",
"short": "Fixture Id of source expression or headerField",
"definition": "Fixture to evaluate the XPath/JSONPath expression or the headerField against.",
"comment": "This can be a statically defined fixture (at the top of the testscript) or a dynamically set fixture created by responseId of the action.operation element.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.assert.validateProfileId",
"path": "TestScript.setup.action.assert.validateProfileId",
"short": "Profile Id of validation profile reference",
"definition": "The ID of the Profile to validate against.",
"comment": "The ID of a Profile fixture. Asserts that the response is valid according to the Profile specified by validateProfileId.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.assert.value",
"path": "TestScript.setup.action.assert.value",
"short": "The value to compare to",
"definition": "The value to compare to.",
"comment": "The string-representation of a number, string, or boolean that is expected. Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before comparing this value to the actual value.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.warningOnly",
"path": "TestScript.setup.action.assert.warningOnly",
"short": "Will this assert produce a warning only on error?",
"definition": "Whether or not the test execution will produce a warning only on error for this assert.",
"comment": "If this element is specified and it is true, then assertion failures can be logged by test engine but should not stop the test script execution from proceeding. There are likely cases where the spec is not clear on what should happen. If the spec says something is optional (maybe a response header for example), but a server doesn’t do it, we could choose to issue a warning.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "TestScript.test",
"path": "TestScript.test",
"short": "A test in this script",
"definition": "A test in this script.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.test.id",
"path": "TestScript.test.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.test.extension",
"path": "TestScript.test.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.test.modifierExtension",
"path": "TestScript.test.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.test.name",
"path": "TestScript.test.name",
"short": "Tracking/logging name of this test",
"definition": "The name of this test used for tracking/logging purposes by test engines.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.test.description",
"path": "TestScript.test.description",
"short": "Tracking/reporting short description of the test",
"definition": "A short description of the test used by test engines for tracking and reporting purposes.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.test.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "TestAction"
}
],
"path": "TestScript.test.action",
"short": "A test operation or assert to perform",
"definition": "Action would contain either an operation or an assertion.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "inv-2",
"severity": "error",
"human": "Test action SHALL contain either an operation or assert but not both.",
"expression": "operation.exists() xor assert.exists()",
"xpath": "(f:operation or f:assert) and not(f:operation and f:assert)"
}
]
},
{
"id": "TestScript.test.action.id",
"path": "TestScript.test.action.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.test.action.extension",
"path": "TestScript.test.action.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.test.action.modifierExtension",
"path": "TestScript.test.action.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.test.action.operation",
"path": "TestScript.test.action.operation",
"short": "The setup operation to perform",
"definition": "An operation would involve a REST request to a server.",
"min": 0,
"max": "1",
"contentReference": "#TestScript.setup.action.operation",
"constraint": [
{
"key": "inv-8",
"severity": "error",
"human": "Test operation SHALL contain either sourceId or targetId or params or url.",
"expression": "sourceId.exists() or (targetId.count() + url.count() + params.count() = 1) or (type.code in ('capabilities' | 'search' | 'transaction' | 'history'))",
"xpath": "f:sourceId or (f:targetId or f:url or f:params) and (count(f:targetId) + count(f:url) + count(f:params) =1) or (f:type/f:code/@value='capabilities' or f:type/f:code/@value='search' or f:type/f:code/@value='transaction' or f:type/f:code/@value='history')"
}
]
},
{
"id": "TestScript.test.action.assert",
"path": "TestScript.test.action.assert",
"short": "The setup assertion to perform",
"definition": "Evaluates the results of previous operations to determine if the server under test behaves appropriately.",
"comment": "In order to evaluate an assertion, the request, response, and results of the most recently executed operation must always be maintained by the test engine.",
"min": 0,
"max": "1",
"contentReference": "#TestScript.setup.action.assert",
"constraint": [
{
"key": "inv-6",
"severity": "error",
"human": "Only a single assertion SHALL be present within test action assert element.",
"expression": "contentType.count() + expression.count() + headerField.count() + minimumId.count() + navigationLinks.count() + path.count() + requestMethod.count() + resource.count() + responseCode.count() + response.count() + rule.count() + ruleset.count() + validateProfileId.count() <=1",
"xpath": "count(f:contentType) + count(f:expression) + count(f:headerField) + count(f:minimumId) + count(f:navigationLinks) + count(f:path) + count(f:requestMethod) + count(f:resource) + count(f:responseCode) + count(f:response) + count(f:rule) + count(f:ruleset) + count(f:validateProfileId) <=1"
},
{
"key": "inv-11",
"severity": "error",
"human": "Test action assert SHALL contain either compareToSourceId and compareToSourceExpression, compareToSourceId and compareToSourcePath or neither.",
"expression": "compareToSourceId.empty() xor (compareToSourceExpression.exists() or compareToSourcePath.exists())",
"xpath": "(f:compareToSourceId and f:compareToSourceExpression) or (f:compareToSourceId and f:compareToSourcePath) or not(f:compareToSourceId or f:compareToSourceExpression or f:compareToSourcePath)"
},
{
"key": "inv-13",
"severity": "error",
"human": "Test action assert response and response and responseCode SHALL be empty when direction equals request",
"expression": "(response.empty() and responseCode.empty() and direction = 'request') or direction.empty() or direction = 'response'",
"xpath": "((count(f:response) + count(f:responseCode)) = 0 and (f:direction/@value='request')) or (count(f:direction) = 0) or (f:direction/@value='response')"
}
]
},
{
"id": "TestScript.teardown",
"path": "TestScript.teardown",
"short": "A series of required clean up steps",
"definition": "A series of operations required to clean up after the all the tests are executed (successfully or otherwise).",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.teardown.id",
"path": "TestScript.teardown.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.teardown.extension",
"path": "TestScript.teardown.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.teardown.modifierExtension",
"path": "TestScript.teardown.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.teardown.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "TeardownAction"
}
],
"path": "TestScript.teardown.action",
"short": "One or more teardown operations to perform",
"definition": "The teardown action will only contain an operation.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "TestScript.teardown.action.id",
"path": "TestScript.teardown.action.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.teardown.action.extension",
"path": "TestScript.teardown.action.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "TestScript.teardown.action.modifierExtension",
"path": "TestScript.teardown.action.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "TestScript.teardown.action.operation",
"path": "TestScript.teardown.action.operation",
"short": "The teardown operation to perform",
"definition": "An operation would involve a REST request to a server.",
"min": 1,
"max": "1",
"contentReference": "#TestScript.setup.action.operation",
"constraint": [
{
"key": "inv-9",
"severity": "error",
"human": "Teardown operation SHALL contain either sourceId or targetId or params or url.",
"expression": "sourceId.exists() or (targetId.count() + url.count() + params.count() = 1) or (type.code in ('capabilities' | 'search' | 'transaction' | 'history'))",
"xpath": "f:sourceId or (f:targetId or f:url or (f:params and f:resource)) and (count(f:targetId) + count(f:url) + count(f:params) =1) or (f:type/f:code/@value='capabilities' or f:type/f:code/@value='search' or f:type/f:code/@value='transaction' or f:type/f:code/@value='history')"
}
]
}
]
},
"differential": {
"element": [
{
"id": "TestScript",
"path": "TestScript",
"short": "Describes a set of tests",
"definition": "A structured set of tests against a FHIR server implementation to determine compliance against the FHIR specification.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "w5",
"map": "conformance.misc"
}
]
},
{
"id": "TestScript.url",
"path": "TestScript.url",
"short": "Logical URI to reference this test script (globally unique)",
"definition": "An absolute URI that is used to identify this test script when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this test script is (or will be) published. The URL SHOULD include the major version of the test script. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the test script to be referenced by a single globally unique identifier.",
"alias": [
"url",
"authoritative-url",
"destination",
"identity"
],
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "TestScript.identifier",
"path": "TestScript.identifier",
"short": "Additional identifier for the test script",
"definition": "A formal identifier that is used to identify this test script when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this test script outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "1",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "TestScript.version",
"path": "TestScript.version",
"short": "Business version of the test script",
"definition": "The identifier that is used to identify this version of the test script when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the test script author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different test script instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the test script with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "TestScript.name",
"path": "TestScript.name",
"short": "Name for this test script (computer friendly)",
"definition": "A natural language name identifying the test script. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "TestScript.title",
"path": "TestScript.title",
"short": "Name for this test script (human friendly)",
"definition": "A short, descriptive, user-friendly title for the test script.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "TestScript.status",
"path": "TestScript.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this test script. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of test scripts that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired test script without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "TestScript.experimental",
"path": "TestScript.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this test script is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of test script that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental test script in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level test script.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "TestScript.date",
"path": "TestScript.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the test script was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the test script changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the test script. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "TestScript.publisher",
"path": "TestScript.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the test script.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the test script is the organization or individual primarily responsible for the maintenance and upkeep of the test script. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the test script. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the test script. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "TestScript.contact",
"path": "TestScript.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "TestScript.description",
"path": "TestScript.description",
"short": "Natural language description of the test script",
"definition": "A free text natural language description of the test script from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the test script was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the test script as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
},
{
"id": "TestScript.useContext",
"path": "TestScript.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate test script instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "TestScript.jurisdiction",
"path": "TestScript.jurisdiction",
"short": "Intended jurisdiction for test script (if applicable)",
"definition": "A legal or geographic region in which the test script is intended to be used.",
"comment": "It may be possible for the test script to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "TestScript.purpose",
"path": "TestScript.purpose",
"short": "Why this test script is defined",
"definition": "Explaination of why this test script is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the test script Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this test script.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "TestScript.copyright",
"path": "TestScript.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the test script and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the test script.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the test script and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "TestScript.origin",
"path": "TestScript.origin",
"short": "An abstract server representing a client or sender in a message exchange",
"definition": "An abstract server used in operations within this test script in the origin element.",
"comment": "The purpose of this element is to define the profile of an origin element used elsewhere in the script. Test engines could then use the origin-profile mapping to offer a filtered list of test systems that can serve as the sender for the interaction.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.origin.index",
"path": "TestScript.origin.index",
"short": "The index of the abstract origin server starting at 1",
"definition": "Abstract name given to an origin server in this test script. The name is provided as a number starting at 1.",
"comment": "A given origin index (e.g. 1) can appear only once in the list (e.g. Origin 1 cannot be specified twice ... once as FormFiller and and again as FormProcessor within the same script as that could get confusing during test configuration). \n\nDifferent origin indices could play the same actor in the same test script (e.g. You could have two different test systems acting as Form-Filler).\n\nThe origin indices provided elsewhere in the test script must be one of these origin indices.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.origin.profile",
"path": "TestScript.origin.profile",
"short": "FHIR-Client | FHIR-SDC-FormFiller",
"definition": "The type of origin profile the test system supports.",
"comment": "Must be a \"sender\"/\"client\" profile.",
"min": 1,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"meaningWhenMissing": "FHIR-Client",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestScriptProfileOriginType"
}
],
"strength": "extensible",
"description": "The type of origin profile the test system supports.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/testscript-profile-origin-types"
}
}
},
{
"id": "TestScript.destination",
"path": "TestScript.destination",
"short": "An abstract server representing a destination or receiver in a message exchange",
"definition": "An abstract server used in operations within this test script in the destination element.",
"comment": "The purpose of this element is to define the profile of a destination element used elsewhere in the script. Test engines could then use the destination-profile mapping to offer a filtered list of test systems that can serve as the receiver for the interaction.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.destination.index",
"path": "TestScript.destination.index",
"short": "The index of the abstract destination server starting at 1",
"definition": "Abstract name given to a destination server in this test script. The name is provided as a number starting at 1.",
"comment": "A given destination index (e.g. 1) can appear only once in the list (e.g. Destination 1 cannot be specified twice ... once as Form-Manager and again as Form-Processor within the same script as that could get confusing during test configuration). \n\nDifferent destination indices could play the same actor in the same test script (e.g. You could have two different test systems acting as Form-Manager).\n\nThe destination indices provided elsewhere in the test script must be one of these destination indices.",
"min": 1,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.destination.profile",
"path": "TestScript.destination.profile",
"short": "FHIR-Server | FHIR-SDC-FormManager | FHIR-SDC-FormReceiver | FHIR-SDC-FormProcessor",
"definition": "The type of destination profile the test system supports.",
"comment": "Must be a \"receiver\"/\"server\" profile.",
"min": 1,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"meaningWhenMissing": "FHIR-Server",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestScriptProfileDestinationType"
}
],
"strength": "extensible",
"description": "The type of destination profile the test system supports.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/testscript-profile-destination-types"
}
}
},
{
"id": "TestScript.metadata",
"path": "TestScript.metadata",
"short": "Required capability that is assumed to function correctly on the FHIR server being tested",
"definition": "The required capability must exist and are assumed to function correctly on the FHIR server being tested.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "inv-4",
"severity": "error",
"human": "TestScript metadata capability SHALL contain required or validated or both.",
"expression": "capability.required.exists() or capability.validated.exists()",
"xpath": "f:capability/f:required or f:capability/f:validated or (f:capability/f:required and f:capability/f:validated)"
}
]
},
{
"id": "TestScript.metadata.link",
"path": "TestScript.metadata.link",
"short": "Links to the FHIR specification",
"definition": "A link to the FHIR specification that this test is covering.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.metadata.link.url",
"path": "TestScript.metadata.link.url",
"short": "URL to the specification",
"definition": "URL to a particular requirement or feature within the FHIR specification.",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "TestScript.metadata.link.description",
"path": "TestScript.metadata.link.description",
"short": "Short description",
"definition": "Short description of the link.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.metadata.capability",
"path": "TestScript.metadata.capability",
"short": "Capabilities that are assumed to function correctly on the FHIR server being tested",
"definition": "Capabilities that must exist and are assumed to function correctly on the FHIR server being tested.",
"comment": "When the metadata capabilities section is defined at TestScript.metadata or at TestScript.setup.metadata, and the server's conformance statement does not contain the elements defined in the minimal conformance statement, then all the tests in the TestScript are skipped. When the metadata capabilities section is defined at TestScript.test.metadata and the server's conformance statement does not contain the elements defined in the minimal conformance statement, then only that test is skipped. The \"metadata.capabilities.required\" and \"metadata.capabilities.validated\" elements only indicate whether the capabilities are the primary focus of the test script or not. They do not impact the skipping logic. Capabilities whose \"metadata.capabilities.validated\" flag is true are the primary focus of the test script.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.metadata.capability.required",
"path": "TestScript.metadata.capability.required",
"short": "Are the capabilities required?",
"definition": "Whether or not the test execution will require the given capabilities of the server in order for this test script to execute.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "TestScript.metadata.capability.validated",
"path": "TestScript.metadata.capability.validated",
"short": "Are the capabilities validated?",
"definition": "Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "TestScript.metadata.capability.description",
"path": "TestScript.metadata.capability.description",
"short": "The expected capabilities of the server",
"definition": "Description of the capabilities that this test script is requiring the server to support.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.metadata.capability.origin",
"path": "TestScript.metadata.capability.origin",
"short": "Which origin server these requirements apply to",
"definition": "Which origin server these requirements apply to.",
"min": 0,
"max": "*",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.metadata.capability.destination",
"path": "TestScript.metadata.capability.destination",
"short": "Which server these requirements apply to",
"definition": "Which server these requirements apply to.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.metadata.capability.link",
"path": "TestScript.metadata.capability.link",
"short": "Links to the FHIR specification",
"definition": "Links to the FHIR specification that describes this interaction and the resources involved in more detail.",
"min": 0,
"max": "*",
"type": [
{
"code": "uri"
}
]
},
{
"id": "TestScript.metadata.capability.capabilities",
"path": "TestScript.metadata.capability.capabilities",
"short": "Required Capability Statement",
"definition": "Minimum capabilities required of server for test script to execute successfully. If server does not meet at a minimum the referenced capability statement, then all tests in this script are skipped.",
"comment": "The conformance statement of the server has to contain at a minimum the contents of the reference pointed to by this element.",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/CapabilityStatement"
}
]
},
{
"id": "TestScript.fixture",
"path": "TestScript.fixture",
"short": "Fixture in the test script - by reference (uri)",
"definition": "Fixture in the test script - by reference (uri). All fixtures are required for the test script to execute.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.fixture.autocreate",
"path": "TestScript.fixture.autocreate",
"short": "Whether or not to implicitly create the fixture during setup",
"definition": "Whether or not to implicitly create the fixture during setup. If true, the fixture is automatically created on each server being tested during setup, therefore no create operation is required for this fixture in the TestScript.setup section.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "TestScript.fixture.autodelete",
"path": "TestScript.fixture.autodelete",
"short": "Whether or not to implicitly delete the fixture during teardown",
"definition": "Whether or not to implicitly delete the fixture during teardown. If true, the fixture is automatically deleted on each server being tested during teardown, therefore no delete operation is required for this fixture in the TestScript.teardown section.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "TestScript.fixture.resource",
"path": "TestScript.fixture.resource",
"short": "Reference of the resource",
"definition": "Reference to the resource (containing the contents of the resource needed for operations).",
"comment": "See http://build.fhir.org/resourcelist.html for complete list of resource types.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "TestScript.profile",
"path": "TestScript.profile",
"short": "Reference of the validation profile",
"definition": "Reference to the profile to be used for validation.",
"comment": "See http://build.fhir.org/resourcelist.html for complete list of resource types.",
"min": 0,
"max": "*",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "TestScript.variable",
"path": "TestScript.variable",
"short": "Placeholder for evaluated elements",
"definition": "Variable is set based either on element value in response body or on header field value in the response headers.",
"comment": "Variables would be set based either on XPath/JSONPath expressions against fixtures (static and response), or headerField evaluations against response headers. If variable evaluates to nodelist or anything other than a primitive value, then test engine would report an error. Variables would be used to perform clean replacements in \"operation.params\", \"operation.requestHeader.value\", and \"operation.url\" element values during operation calls and in \"assert.value\" during assertion evaluations. This limits the places that test engines would need to look for placeholders \"${}\". Variables are scoped to the whole script. They are NOT evaluated at declaration. They are evaluated by test engine when used for substitutions in \"operation.params\", \"operation.requestHeader.value\", and \"operation.url\" element values during operation calls and in \"assert.value\" during assertion evaluations. See example testscript-search.xml.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "inv-3",
"severity": "error",
"human": "Variable can only contain one of expression, headerField or path.",
"expression": "expression.empty() or headerField.empty() or path.empty()",
"xpath": "not(f:expression and f:headerField and f:path)"
}
]
},
{
"id": "TestScript.variable.name",
"path": "TestScript.variable.name",
"short": "Descriptive name for this variable",
"definition": "Descriptive name for this variable.",
"comment": "Placeholders would contain the variable name wrapped in ${} in \"operation.params\", \"operation.requestHeader.value\", and \"operation.url\" elements. These placeholders would need to be replaced by the variable value before the operation is executed.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.defaultValue",
"path": "TestScript.variable.defaultValue",
"short": "Default, hard-coded, or user-defined value for this variable",
"definition": "A default, hard-coded, or user-defined value for this variable.",
"comment": "The purpose of this element is to allow for a pre-defined value that can be used as a default or as an override value. Test engines can optionally use this as a placeholder for user-defined execution time values.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.description",
"path": "TestScript.variable.description",
"short": "Natural language description of the variable",
"definition": "A free text natural language description of the variable and its purpose.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.expression",
"path": "TestScript.variable.expression",
"short": "The fluentpath expression against the fixture body",
"definition": "The fluentpath expression to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.",
"comment": "If headerField is defined, then the variable will be evaluated against the headers that sourceId is pointing to. If expression or path is defined, then the variable will be evaluated against the fixture body that sourceId is pointing to. It is an error to define any combination of expression, headerField and path.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.headerField",
"path": "TestScript.variable.headerField",
"short": "HTTP header field name for source",
"definition": "Will be used to grab the HTTP header field value from the headers that sourceId is pointing to.",
"comment": "If headerField is defined, then the variable will be evaluated against the headers that sourceId is pointing to. If path is defined, then the variable will be evaluated against the fixture body that sourceId is pointing to. It is an error to define both headerField and path.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.hint",
"path": "TestScript.variable.hint",
"short": "Hint help text for default value to enter",
"definition": "Displayable text string with hint help information to the user when entering a default value.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.path",
"path": "TestScript.variable.path",
"short": "XPath or JSONPath against the fixture body",
"definition": "XPath or JSONPath to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.",
"comment": "If headerField is defined, then the variable will be evaluated against the headers that sourceId is pointing to. If expression or path is defined, then the variable will be evaluated against the fixture body that sourceId is pointing to. It is an error to define any combination of expression, headerField and path.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.variable.sourceId",
"path": "TestScript.variable.sourceId",
"short": "Fixture Id of source expression or headerField within this variable",
"definition": "Fixture to evaluate the XPath/JSONPath expression or the headerField against within this variable.",
"comment": "This can be a statically defined fixture (at the top of the TestScript) or a dynamically set fixture created by responseId of the `action.operation` element.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.rule",
"path": "TestScript.rule",
"short": "Assert rule used within the test script",
"definition": "Assert rule to be used in one or more asserts within the test script.",
"comment": "Each rule should be treated by test engines as one assertion regardless of how many assertions are contained within the external rule template. The impact of negative rule evaluation on test script execution is the same as an assertion failure which is described elsewhere in the TestScript resource.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.rule.resource",
"path": "TestScript.rule.resource",
"short": "Assert rule resource reference",
"definition": "Reference to the resource (containing the contents of the rule needed for assertions).",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "TestScript.rule.param",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "RuleParam"
}
],
"path": "TestScript.rule.param",
"short": "Rule parameter template",
"definition": "Each rule template can take one or more parameters for rule evaluation.",
"comment": "The parameter value can be dynamic at runtime.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.rule.param.name",
"path": "TestScript.rule.param.name",
"short": "Parameter name matching external assert rule parameter",
"definition": "Descriptive name for this parameter that matches the external assert rule parameter name.",
"comment": "The external rule template would be looking for the parameter by this name.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.rule.param.value",
"path": "TestScript.rule.param.value",
"short": "Parameter value defined either explicitly or dynamically",
"definition": "The explicit or dynamic value for the parameter that will be passed on to the external rule template.",
"comment": "This value can be overwritten by the assert.rule.param.value i.e. TestScript.rule.param.value will be used if assert.rule.param.value is not specified. The param value can be a string-representation of a number, string, or boolean that is expected. Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before supplying this value to the external rule template.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.ruleset",
"path": "TestScript.ruleset",
"short": "Assert ruleset used within the test script",
"definition": "Contains one or more rules. Offers a way to group rules so assertions could reference the group of rules and have them all applied.",
"comment": "Each rule within a ruleset should be treated by test engines as one assertion regardless of how many assertions are contained within the external rule template. The impact of negative rule evaluation on test script execution is the same as an assertion failure which is described elsewhere in the TestScript resource.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.ruleset.resource",
"path": "TestScript.ruleset.resource",
"short": "Assert ruleset resource reference",
"definition": "Reference to the resource (containing the contents of the ruleset needed for assertions).",
"min": 1,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Resource"
}
]
},
{
"id": "TestScript.ruleset.rule",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "RulesetRule"
}
],
"path": "TestScript.ruleset.rule",
"short": "The referenced rule within the ruleset",
"definition": "The referenced rule within the external ruleset template.",
"comment": "This qualifies each param name so that a parameter with the same name can be used differently by the different rules with the ruleset.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.ruleset.rule.ruleId",
"path": "TestScript.ruleset.rule.ruleId",
"short": "Id of referenced rule within the ruleset",
"definition": "Id of the referenced rule within the external ruleset template.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.ruleset.rule.param",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "RulesetRuleParam"
}
],
"path": "TestScript.ruleset.rule.param",
"short": "Ruleset rule parameter template",
"definition": "Each rule template can take one or more parameters for rule evaluation.",
"comment": "The parameter value can be dynamic at runtime.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.ruleset.rule.param.name",
"path": "TestScript.ruleset.rule.param.name",
"short": "Parameter name matching external assert ruleset rule parameter",
"definition": "Descriptive name for this parameter that matches the external assert ruleset rule parameter name.",
"comment": "The external rule template would be looking for the parameter by this name.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.ruleset.rule.param.value",
"path": "TestScript.ruleset.rule.param.value",
"short": "Parameter value defined either explicitly or dynamically",
"definition": "The value for the parameter that will be passed on to the external ruleset rule template.",
"comment": "This value can be overwritten by the assert.ruleset.rule.param.value i.e. TestScript.ruleset.rule.param.value will be used if assert.ruleset.rule.param.value is not specified. The param value can be a string-representation of a number, string, or boolean that is expected. Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before supplying this value to the external rule template.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup",
"path": "TestScript.setup",
"short": "A series of required setup operations before tests are executed",
"definition": "A series of required setup operations before tests are executed.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.setup.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "SetupAction"
}
],
"path": "TestScript.setup.action",
"short": "A setup operation or assert to perform",
"definition": "Action would contain either an operation or an assertion.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "inv-1",
"severity": "error",
"human": "Setup action SHALL contain either an operation or assert but not both.",
"expression": "operation.exists() xor assert.exists()",
"xpath": "(f:operation or f:assert) and not(f:operation and f:assert)"
}
]
},
{
"id": "TestScript.setup.action.operation",
"path": "TestScript.setup.action.operation",
"short": "The setup operation to perform",
"definition": "The operation to perform.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "inv-7",
"severity": "error",
"human": "Setup operation SHALL contain either sourceId or targetId or params or url.",
"expression": "sourceId.exists() or (targetId.count() + url.count() + params.count() = 1) or (type.code in ('capabilities' |'search' | 'transaction' | 'history'))",
"xpath": "f:sourceId or ((f:targetId or f:url or f:params) and (count(f:targetId) + count(f:url) + count(f:params) =1)) or (f:type/f:code/@value='capabilities' or f:type/f:code/@value='search' or f:type/f:code/@value='transaction' or f:type/f:code/@value='history')"
}
]
},
{
"id": "TestScript.setup.action.operation.type",
"path": "TestScript.setup.action.operation.type",
"short": "The operation code type that will be executed",
"definition": "Server interaction or operation type.",
"comment": "See http://build.fhir.org/http.html for list of server interactions.",
"min": 0,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestScriptOperationCode"
}
],
"strength": "extensible",
"description": "The allowable operation code types.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/testscript-operation-codes"
}
}
},
{
"id": "TestScript.setup.action.operation.resource",
"path": "TestScript.setup.action.operation.resource",
"short": "Resource type",
"definition": "The type of the resource. See http://build.fhir.org/resourcelist.html.",
"comment": "If \"url\" element is specified, then \"targetId\", \"params\", and \"resource\" elements will be ignored as \"url\" element will have everything needed for constructing the request url. If \"params\" element is specified, then \"targetId\" element is ignored. For FHIR operations that require a resource (e.g. \"read\" and \"vread\" operations), the \"resource\" element must be specified when \"params\" element is specified. If \"url\" and \"params\" elements are absent, then the request url will be constructed from \"targetId\" fixture if present. For \"read\" operation, the resource and id values will be extracted from \"targetId\" fixture and used to construct the url. For \"vread\" and \"history\" operations, the versionId value will also be used.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FHIRDefinedType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Either a resource or a data type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/defined-types"
}
}
},
{
"id": "TestScript.setup.action.operation.label",
"path": "TestScript.setup.action.operation.label",
"short": "Tracking/logging operation label",
"definition": "The label would be used for tracking/logging purposes by test engines.",
"comment": "This has no impact on the verification itself.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.operation.description",
"path": "TestScript.setup.action.operation.description",
"short": "Tracking/reporting operation description",
"definition": "The description would be used by test engines for tracking and reporting purposes.",
"comment": "This has no impact on the verification itself.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.operation.accept",
"path": "TestScript.setup.action.operation.accept",
"short": "xml | json | ttl | none",
"definition": "The content-type or mime-type to use for RESTful operation in the 'Accept' header.",
"comment": "If this is specified, then test engine shall set the 'Accept' header to the corresponding value. If 'xml' is specified, then 'Accept' header of 'application/fhir+xml' will be set. If 'json' is specified, then 'application/fhir+json' will be used. If you'd like to explicitly set the 'Accept' to some other value then use the 'requestHeader' element.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "xml",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ContentType"
}
],
"strength": "required",
"description": "The content or mime type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/content-type"
}
}
},
{
"id": "TestScript.setup.action.operation.contentType",
"path": "TestScript.setup.action.operation.contentType",
"short": "xml | json | ttl | none",
"definition": "The content-type or mime-type to use for RESTful operation in the 'Content-Type' header.",
"comment": "If this is specified, then test engine shall set the 'Content-Type' header to the corresponding value. If 'xml' is specified, then 'Content-Type' header of 'application/fhir+xml' will be set. If 'json' is specified, then 'application/fhir+json' will be used. If you'd like to explicitly set the 'Content-Type' to some other value then use the 'requestHeader' element.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "xml",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ContentType"
}
],
"strength": "required",
"description": "The content or mime type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/content-type"
}
}
},
{
"id": "TestScript.setup.action.operation.destination",
"path": "TestScript.setup.action.operation.destination",
"short": "Server responding to the request",
"definition": "The server where the request message is destined for. Must be one of the server numbers listed in TestScript.destination section.",
"comment": "If multiple TestScript.destination elements are defined and operation.destination is undefined, test engine will report an error as it cannot determine what destination to use for the exchange.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.setup.action.operation.encodeRequestUrl",
"path": "TestScript.setup.action.operation.encodeRequestUrl",
"short": "Whether or not to send the request url in encoded format",
"definition": "Whether or not to implicitly send the request url in encoded format. The default is true to match the standard RESTful client behavior. Set to false when communicating with a server that does not support encoded url paths.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": true
},
{
"id": "TestScript.setup.action.operation.origin",
"path": "TestScript.setup.action.operation.origin",
"short": "Server initiating the request",
"definition": "The server where the request message originates from. Must be one of the server numbers listed in TestScript.origin section.",
"comment": "If absent, test engine will send the message. When present, test engine will not send the request message but will wait for the request message to be sent from this origin server.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "TestScript.setup.action.operation.params",
"path": "TestScript.setup.action.operation.params",
"short": "Explicitly defined path parameters",
"definition": "Path plus parameters after [type]. Used to set parts of the request URL explicitly.",
"comment": "If \"url\" element is specified, then \"targetId\", \"params\", and \"resource\" elements will be ignored as \"url\" element will have everything needed for constructing the request url. If \"params\" element is specified, then \"targetId\" element is ignored. For FHIR operations that require a resource (e.g. \"read\" and \"vread\" operations), the \"resource\" element must be specified when \"params\" element is specified. If \"url\" and \"params\" elements are absent, then the request url will be constructed from \"targetId\" fixture if present. For \"read\" operation, the resource and id values will be extracted from \"targetId\" fixture and used to construct the url. For \"vread\" and \"history\" operations, the versionId value will also be used. Test engines would append whatever is specified for \"params\" to the URL after the resource type without tampering with the string (beyond encoding the URL for HTTP). The \"params\" element does not correspond exactly to \"search parameters\". Nor is it the \"path\". It corresponds to the part of the URL that comes after the [type] (when \"resource\" element is specified); e.g. It corresponds to \"/[id]/_history/[vid] {?_format=[mime-type]}\" in the following operation: GET [base]/[type]/[id]/_history/[vid] {?_format=[mime-type]} Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before sending the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.operation.requestHeader",
"path": "TestScript.setup.action.operation.requestHeader",
"short": "Each operation can have one or more header elements",
"definition": "Header elements would be used to set HTTP headers.",
"comment": "This gives control to test-script writers to set headers explicitly based on test requirements. It will allow for testing using: - \"If-Modified-Since\" and \"If-None-Match\" headers. See http://build.fhir.org/http.html#2.1.0.5.1 - \"If-Match\" header. See http://build.fhir.org/http.html#2.1.0.11 - Conditional Create using \"If-None-Exist\". See http://build.fhir.org/http.html#2.1.0.13.1 - Invalid \"Content-Type\" header for negative testing. - etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.setup.action.operation.requestHeader.field",
"path": "TestScript.setup.action.operation.requestHeader.field",
"short": "HTTP header field name",
"definition": "The HTTP header field e.g. \"Accept\".",
"comment": "If header element is specified, then field is required.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.operation.requestHeader.value",
"path": "TestScript.setup.action.operation.requestHeader.value",
"short": "HTTP headerfield value",
"definition": "The value of the header e.g. \"application/fhir+xml\".",
"comment": "If header element is specified, then value is required. No conversions will be done by the test engine e.g. \"xml\" to \"application/fhir+xml\". The values will be set in HTTP headers \"as-is\". Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before sending the request.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.operation.requestId",
"path": "TestScript.setup.action.operation.requestId",
"short": "Fixture Id of mapped request",
"definition": "The fixture id (maybe new) to map to the request.",
"comment": "If a requestId is supplied, then the resulting request (both headers and body) is mapped to the fixture ID (which may be entirely new and previously undeclared) designated by \"requestId\". If requestId is not specified, it is the test engine's responsibility to store the request and use it as the requestId in subsequent assertions when assertion path and/or headerField is specified, direction is equal to request, and the requestId in not specified.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.operation.responseId",
"path": "TestScript.setup.action.operation.responseId",
"short": "Fixture Id of mapped response",
"definition": "The fixture id (maybe new) to map to the response.",
"comment": "If a responseId is supplied, and the server responds, then the resulting response (both headers and body) is mapped to the fixture ID (which may be entirely new and previously undeclared) designated by \"responseId\". If responseId is not specified, it is the test engine's responsibility to store the response and use it as the responseId in subsequent assertions when assertion path and/or headerField is specified and the responseId is not specified.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.operation.sourceId",
"path": "TestScript.setup.action.operation.sourceId",
"short": "Fixture Id of body for PUT and POST requests",
"definition": "The id of the fixture used as the body of a PUT or POST request.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.operation.targetId",
"path": "TestScript.setup.action.operation.targetId",
"short": "Id of fixture used for extracting the [id], [type], and [vid] for GET requests",
"definition": "Id of fixture used for extracting the [id], [type], and [vid] for GET requests.",
"comment": "If \"url\" element is specified, then \"targetId\", \"params\", and \"resource\" elements will be ignored as \"url\" element will have everything needed for constructing the request url. If \"params\" element is specified, then \"targetId\" element is ignored. For FHIR operations that require a resource (e.g. \"read\" and \"vread\" operations), the \"resource\" element must be specified when \"params\" element is specified. If \"url\" and \"params\" elements are absent, then the request url will be constructed from \"targetId\" fixture if present. For \"read\" operation, the resource and id values will be extracted from \"targetId\" fixture and used to construct the url. For \"vread\" and \"history\" operations, the versionId value will also be used.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.operation.url",
"path": "TestScript.setup.action.operation.url",
"short": "Request URL",
"definition": "Complete request URL.",
"comment": "Used to set the request URL explicitly. If \"url\" element is defined, then \"targetId\", \"resource\", and \"params\" elements will be ignored. Test engines would use whatever is specified in \"url\" without tampering with the string (beyond encoding the URL for HTTP). Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before sending the request.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert",
"path": "TestScript.setup.action.assert",
"short": "The assertion to perform",
"definition": "Evaluates the results of previous operations to determine if the server under test behaves appropriately.",
"comment": "In order to evaluate an assertion, the request, response, and results of the most recently executed operation must always be maintained by the test engine.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "inv-5",
"severity": "error",
"human": "Only a single assertion SHALL be present within setup action assert element.",
"expression": "contentType.count() + expression.count() + headerField.count() + minimumId.count() + navigationLinks.count() + path.count() + requestMethod.count() + resource.count() + responseCode.count() + response.count() + rule.count() + ruleset.count() + validateProfileId.count() <=1",
"xpath": "count(f:contentType) + count(f:expression) + count(f:headerField) + count(f:minimumId) + count(f:navigationLinks) + count(f:path) + count(f:requestMethod) + count(f:resource) + count(f:responseCode) + count(f:response) + count(f:rule) + count(f:ruleset) + count(f:validateProfileId) <=1"
},
{
"key": "inv-10",
"severity": "error",
"human": "Setup action assert SHALL contain either compareToSourceId and compareToSourceExpression, compareToSourceId and compareToSourcePath or neither.",
"expression": "compareToSourceId.empty() xor (compareToSourceExpression.exists() or compareToSourcePath.exists())",
"xpath": "(f:compareToSourceId and f:compareToSourceExpression) or (f:compareToSourceId and f:compareToSourcePath) or not(f:compareToSourceId or f:compareToSourceExpression or f:compareToSourcePath)"
},
{
"key": "inv-12",
"severity": "error",
"human": "Setup action assert response and responseCode SHALL be empty when direction equals request",
"expression": "(response.empty() and responseCode.empty() and direction = 'request') or direction.empty() or direction = 'response'",
"xpath": "((count(f:response) + count(f:responseCode)) = 0 and (f:direction/@value='request')) or (count(f:direction) = 0) or (f:direction/@value='response')"
}
]
},
{
"id": "TestScript.setup.action.assert.label",
"path": "TestScript.setup.action.assert.label",
"short": "Tracking/logging assertion label",
"definition": "The label would be used for tracking/logging purposes by test engines.",
"comment": "This has no impact on the verification itself.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.description",
"path": "TestScript.setup.action.assert.description",
"short": "Tracking/reporting assertion description",
"definition": "The description would be used by test engines for tracking and reporting purposes.",
"comment": "This has no impact on the verification itself.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.direction",
"path": "TestScript.setup.action.assert.direction",
"short": "response | request",
"definition": "The direction to use for the assertion.",
"comment": "If the direction is specified as \"response\" (the default), then the processing of this assert is against the received response message. If the direction is specified as \"request\", then the processing of this assert is against the sent request message.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AssertionDirectionType"
}
],
"strength": "required",
"description": "The type of direction to use for assertion.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/assert-direction-codes"
}
}
},
{
"id": "TestScript.setup.action.assert.compareToSourceId",
"path": "TestScript.setup.action.assert.compareToSourceId",
"short": "Id of the source fixture to be evaluated",
"definition": "Id of the source fixture used as the contents to be evaluated by either the \"source/expression\" or \"sourceId/path\" definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.compareToSourceExpression",
"path": "TestScript.setup.action.assert.compareToSourceExpression",
"short": "The fluentpath expression to evaluate against the source fixture",
"definition": "The fluentpath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.",
"comment": "Thefhirpath expression to be evaluated against the expected fixture to compare to. Ignored if \"assert.value\" is used. The evaluation will be done before the assertion is evaluated.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.compareToSourcePath",
"path": "TestScript.setup.action.assert.compareToSourcePath",
"short": "XPath or JSONPath expression to evaluate against the source fixture",
"definition": "XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.",
"comment": "The XPath or JSONPath expression to be evaluated against the expected fixture to compare to. Ignored if \"assert.value\" is used. The evaluation will be done before the assertion is evaluated.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.contentType",
"path": "TestScript.setup.action.assert.contentType",
"short": "xml | json | ttl | none",
"definition": "The content-type or mime-type to use for RESTful operation in the 'Content-Type' header.",
"comment": "If this is specified, then test engine shall confirm that the content-type of the last operation's headers is set to this value. If \"assert.sourceId\" element is specified, then the evaluation will be done against the headers mapped to that sourceId (and not the last operation's headers). If 'xml' is specified, then 'Content-Type' header of 'application/fhir+xml' will be confirmed. If 'json' is specified, then 'application/fhir+json' will be used. If you'd like to have more control over the string, then use 'assert.headerField' instead.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "xml",
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ContentType"
}
],
"strength": "required",
"description": "The content or mime type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/content-type"
}
}
},
{
"id": "TestScript.setup.action.assert.expression",
"path": "TestScript.setup.action.assert.expression",
"short": "The fluentpath expression to be evaluated",
"definition": "The fluentpath expression to be evaluated against the request or response message contents - HTTP headers and payload.",
"comment": "If both \"expression\" and a \"fixtureId\" are specified, then the expression will be evaluated against the request or response body mapped to the fixtureId. If \"expression\" is specified and a \"fixtureId\" is not, then the expression will be evaluated against the response body of the last operation. Test engines are to store the request and response body and headers of the last operation at all times for subsequent assertions.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.headerField",
"path": "TestScript.setup.action.assert.headerField",
"short": "HTTP header field name",
"definition": "The HTTP header field name e.g. 'Location'.",
"comment": "If \"headerField\" is specified then \"value\" must be specified. If \"sourceId\" is not specified, then \"headerField\" will be evaluated against the last operation's response headers. Test engines are to keep track of the last operation's response body and response headers.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.minimumId",
"path": "TestScript.setup.action.assert.minimumId",
"short": "Fixture Id of minimum content resource",
"definition": "The ID of a fixture. Asserts that the response contains at a minimum the fixture specified by minimumId.",
"comment": "Asserts that the response contains all the element/content in another fixture pointed to by minimumId. This can be a statically defined fixture or one that is dynamically set via responseId.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.navigationLinks",
"path": "TestScript.setup.action.assert.navigationLinks",
"short": "Perform validation on navigation links?",
"definition": "Whether or not the test execution performs validation on the bundle navigation links.",
"comment": "Asserts that the Bundle contains first, last, and next links.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
]
},
{
"id": "TestScript.setup.action.assert.operator",
"path": "TestScript.setup.action.assert.operator",
"short": "equals | notEquals | in | notIn | greaterThan | lessThan | empty | notEmpty | contains | notContains | eval",
"definition": "The operator type defines the conditional behavior of the assert. If not defined, the default is equals.",
"comment": "Operators are useful especially for negative testing. If operator is not specified, then the \"equals\" operator is assumed; e.g. .",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AssertionOperatorType"
}
],
"strength": "required",
"description": "The type of operator to use for assertion.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/assert-operator-codes"
}
}
},
{
"id": "TestScript.setup.action.assert.path",
"path": "TestScript.setup.action.assert.path",
"short": "XPath or JSONPath expression",
"definition": "The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.",
"comment": "If both \"path\" and a \"fixtureId\" are specified, then the path will be evaluated against the request or response body mapped to the fixtureId. If \"path\" is specified and a \"fixtureId\" is not, then the path will be evaluated against the response body of the last operation. Test engines are to store the request and response body and headers of the last operation at all times for subsequent assertions.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.requestMethod",
"path": "TestScript.setup.action.assert.requestMethod",
"short": "delete | get | options | patch | post | put",
"definition": "The request method or HTTP operation code to compare against that used by the client system under test.",
"comment": "If \"requestMethod\" is specified then it will be used in place of \"value\". The \"requestMethod\" will evaluate against the last operation's request HTTP operation.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TestScriptRequestMethodCode"
}
],
"strength": "required",
"description": "The allowable request method or HTTP operation codes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/http-operations"
}
}
},
{
"id": "TestScript.setup.action.assert.requestURL",
"path": "TestScript.setup.action.assert.requestURL",
"short": "Request URL comparison value",
"definition": "The value to use in a comparison against the request URL path string.",
"comment": "If \"requestURL\" is specified then it will be used in place of \"value\". The \"requestURL\" will evaluate against the last operation's full request URL path string.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.resource",
"path": "TestScript.setup.action.assert.resource",
"short": "Resource type",
"definition": "The type of the resource. See http://build.fhir.org/resourcelist.html.",
"comment": "This will be expected resource type in response body e.g. in read, vread, search, etc. See http://build.fhir.org/resourcelist.html for complete list of resource types; e.g. .",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FHIRDefinedType"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "Either a resource or a data type.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/defined-types"
}
}
},
{
"id": "TestScript.setup.action.assert.response",
"path": "TestScript.setup.action.assert.response",
"short": "okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable",
"definition": "okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable.",
"comment": "This is a shorter way of achieving similar verifications via \"assert.responseCode\". If you need more control, then use \"assert.responseCode\" e.g. .",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "AssertionResponseTypes"
}
],
"strength": "required",
"description": "The type of response code to use for assertion.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/assert-response-code-types"
}
}
},
{
"id": "TestScript.setup.action.assert.responseCode",
"path": "TestScript.setup.action.assert.responseCode",
"short": "HTTP response code to test",
"definition": "The value of the HTTP response code to be tested.",
"comment": "To be used with \"operator\" attribute value. Asserts that the response code equals this value if \"operator\" is not specified. If the operator is \"in\" or \"notIn\" then the responseCode would be a comma-separated list of values e.g. \"200,201\". Otherwise, it's expected to be a numeric value. If \"fixture\" is not specified, then the \"responseBodyId\" value of the last operation is assumed.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.rule",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ActionAssertRule"
}
],
"path": "TestScript.setup.action.assert.rule",
"short": "The reference to a TestScript.rule",
"definition": "The TestScript.rule this assert will evaluate.",
"comment": "Each rule should get evaluated by test engines as one assertion regardless of how many assertions are contained within the external rule template. The impact of negative rule evaluation on test script execution is the same as an assertion failure which is descibed elsewhere in the TestScript resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.ruleId",
"path": "TestScript.setup.action.assert.rule.ruleId",
"short": "Id of the TestScript.rule",
"definition": "The TestScript.rule id value this assert will evaluate.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.param",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ActionAssertRuleParam"
}
],
"path": "TestScript.setup.action.assert.rule.param",
"short": "Rule parameter template",
"definition": "Each rule template can take one or more parameters for rule evaluation.",
"comment": "The parameter value can be dynamic at runtime.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.param.name",
"path": "TestScript.setup.action.assert.rule.param.name",
"short": "Parameter name matching external assert rule parameter",
"definition": "Descriptive name for this parameter that matches the external assert rule parameter name.",
"comment": "The external rule template would be looking for the parameter by this name.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.rule.param.value",
"path": "TestScript.setup.action.assert.rule.param.value",
"short": "Parameter value defined either explicitly or dynamically",
"definition": "The value for the parameter that will be passed on to the external rule template.",
"comment": "This value overwrites the value (if any) specified in TestScript.rule.param.value. The param value can be a string-representation of a number, string, or boolean that is expected. Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before supplying this value to the external rule template.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ActionAssertRuleset"
}
],
"path": "TestScript.setup.action.assert.ruleset",
"short": "The reference to a TestScript.ruleset",
"definition": "The TestScript.ruleset this assert will evaluate.",
"comment": "Each rule within a ruleset should get evaluated by test engines as a separate assertion. The impact of negative rule evaluation on test script execution is the same as an assertion failure which is descibed elsewhere in the TestScript resource. If the first rule within the ruleset results in a failed assertion, then test engines do not have to evaluate the rest of the rules within the ruleset.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rulesetId",
"path": "TestScript.setup.action.assert.ruleset.rulesetId",
"short": "Id of the TestScript.ruleset",
"definition": "The TestScript.ruleset id value this assert will evaluate.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ActionAssertRulesetRule"
}
],
"path": "TestScript.setup.action.assert.ruleset.rule",
"short": "The referenced rule within the ruleset",
"definition": "The referenced rule within the external ruleset template.",
"comment": "This qualifies each param name so that a parameter with the same name can be used differently by the different rules with the ruleset.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.ruleId",
"path": "TestScript.setup.action.assert.ruleset.rule.ruleId",
"short": "Id of referenced rule within the ruleset",
"definition": "Id of the referenced rule within the external ruleset template.",
"min": 1,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.param",
"path": "TestScript.setup.action.assert.ruleset.rule.param",
"short": "Rule parameter template",
"definition": "Each rule template can take one or more parameters for rule evaluation.",
"comment": "The parameter value can be dynamic at runtime.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.param.name",
"path": "TestScript.setup.action.assert.ruleset.rule.param.name",
"short": "Parameter name matching external assert ruleset rule parameter",
"definition": "Descriptive name for this parameter that matches the external assert ruleset rule parameter name.",
"comment": "The external rule template would be looking for the parameter by this name.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.ruleset.rule.param.value",
"path": "TestScript.setup.action.assert.ruleset.rule.param.value",
"short": "Parameter value defined either explicitly or dynamically",
"definition": "The value for the parameter that will be passed on to the external ruleset rule template.",
"comment": "This value overwrites the value (if any) specified in TestScript.ruleset.rule.param.value. The param value can be a string-representation of a number, string, or boolean that is expected. Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before supplying this value to the external rule template.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.sourceId",
"path": "TestScript.setup.action.assert.sourceId",
"short": "Fixture Id of source expression or headerField",
"definition": "Fixture to evaluate the XPath/JSONPath expression or the headerField against.",
"comment": "This can be a statically defined fixture (at the top of the testscript) or a dynamically set fixture created by responseId of the action.operation element.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.assert.validateProfileId",
"path": "TestScript.setup.action.assert.validateProfileId",
"short": "Profile Id of validation profile reference",
"definition": "The ID of the Profile to validate against.",
"comment": "The ID of a Profile fixture. Asserts that the response is valid according to the Profile specified by validateProfileId.",
"min": 0,
"max": "1",
"type": [
{
"code": "id"
}
]
},
{
"id": "TestScript.setup.action.assert.value",
"path": "TestScript.setup.action.assert.value",
"short": "The value to compare to",
"definition": "The value to compare to.",
"comment": "The string-representation of a number, string, or boolean that is expected. Test engines do have to look for placeholders (${}) and replace the variable placeholders with the variable values at runtime before comparing this value to the actual value.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.setup.action.assert.warningOnly",
"path": "TestScript.setup.action.assert.warningOnly",
"short": "Will this assert produce a warning only on error?",
"definition": "Whether or not the test execution will produce a warning only on error for this assert.",
"comment": "If this element is specified and it is true, then assertion failures can be logged by test engine but should not stop the test script execution from proceeding. There are likely cases where the spec is not clear on what should happen. If the spec says something is optional (maybe a response header for example), but a server doesn’t do it, we could choose to issue a warning.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "TestScript.test",
"path": "TestScript.test",
"short": "A test in this script",
"definition": "A test in this script.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.test.name",
"path": "TestScript.test.name",
"short": "Tracking/logging name of this test",
"definition": "The name of this test used for tracking/logging purposes by test engines.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.test.description",
"path": "TestScript.test.description",
"short": "Tracking/reporting short description of the test",
"definition": "A short description of the test used by test engines for tracking and reporting purposes.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "TestScript.test.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "TestAction"
}
],
"path": "TestScript.test.action",
"short": "A test operation or assert to perform",
"definition": "Action would contain either an operation or an assertion.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "inv-2",
"severity": "error",
"human": "Test action SHALL contain either an operation or assert but not both.",
"expression": "operation.exists() xor assert.exists()",
"xpath": "(f:operation or f:assert) and not(f:operation and f:assert)"
}
]
},
{
"id": "TestScript.test.action.operation",
"path": "TestScript.test.action.operation",
"short": "The setup operation to perform",
"definition": "An operation would involve a REST request to a server.",
"min": 0,
"max": "1",
"contentReference": "#TestScript.setup.action.operation",
"constraint": [
{
"key": "inv-8",
"severity": "error",
"human": "Test operation SHALL contain either sourceId or targetId or params or url.",
"expression": "sourceId.exists() or (targetId.count() + url.count() + params.count() = 1) or (type.code in ('capabilities' | 'search' | 'transaction' | 'history'))",
"xpath": "f:sourceId or (f:targetId or f:url or f:params) and (count(f:targetId) + count(f:url) + count(f:params) =1) or (f:type/f:code/@value='capabilities' or f:type/f:code/@value='search' or f:type/f:code/@value='transaction' or f:type/f:code/@value='history')"
}
]
},
{
"id": "TestScript.test.action.assert",
"path": "TestScript.test.action.assert",
"short": "The setup assertion to perform",
"definition": "Evaluates the results of previous operations to determine if the server under test behaves appropriately.",
"comment": "In order to evaluate an assertion, the request, response, and results of the most recently executed operation must always be maintained by the test engine.",
"min": 0,
"max": "1",
"contentReference": "#TestScript.setup.action.assert",
"constraint": [
{
"key": "inv-6",
"severity": "error",
"human": "Only a single assertion SHALL be present within test action assert element.",
"expression": "contentType.count() + expression.count() + headerField.count() + minimumId.count() + navigationLinks.count() + path.count() + requestMethod.count() + resource.count() + responseCode.count() + response.count() + rule.count() + ruleset.count() + validateProfileId.count() <=1",
"xpath": "count(f:contentType) + count(f:expression) + count(f:headerField) + count(f:minimumId) + count(f:navigationLinks) + count(f:path) + count(f:requestMethod) + count(f:resource) + count(f:responseCode) + count(f:response) + count(f:rule) + count(f:ruleset) + count(f:validateProfileId) <=1"
},
{
"key": "inv-11",
"severity": "error",
"human": "Test action assert SHALL contain either compareToSourceId and compareToSourceExpression, compareToSourceId and compareToSourcePath or neither.",
"expression": "compareToSourceId.empty() xor (compareToSourceExpression.exists() or compareToSourcePath.exists())",
"xpath": "(f:compareToSourceId and f:compareToSourceExpression) or (f:compareToSourceId and f:compareToSourcePath) or not(f:compareToSourceId or f:compareToSourceExpression or f:compareToSourcePath)"
},
{
"key": "inv-13",
"severity": "error",
"human": "Test action assert response and response and responseCode SHALL be empty when direction equals request",
"expression": "(response.empty() and responseCode.empty() and direction = 'request') or direction.empty() or direction = 'response'",
"xpath": "((count(f:response) + count(f:responseCode)) = 0 and (f:direction/@value='request')) or (count(f:direction) = 0) or (f:direction/@value='response')"
}
]
},
{
"id": "TestScript.teardown",
"path": "TestScript.teardown",
"short": "A series of required clean up steps",
"definition": "A series of operations required to clean up after the all the tests are executed (successfully or otherwise).",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.teardown.action",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "TeardownAction"
}
],
"path": "TestScript.teardown.action",
"short": "One or more teardown operations to perform",
"definition": "The teardown action will only contain an operation.",
"comment": "An action should contain either an operation or an assertion but not both. It can contain any number of variables.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "TestScript.teardown.action.operation",
"path": "TestScript.teardown.action.operation",
"short": "The teardown operation to perform",
"definition": "An operation would involve a REST request to a server.",
"min": 1,
"max": "1",
"contentReference": "#TestScript.setup.action.operation",
"constraint": [
{
"key": "inv-9",
"severity": "error",
"human": "Teardown operation SHALL contain either sourceId or targetId or params or url.",
"expression": "sourceId.exists() or (targetId.count() + url.count() + params.count() = 1) or (type.code in ('capabilities' | 'search' | 'transaction' | 'history'))",
"xpath": "f:sourceId or (f:targetId or f:url or (f:params and f:resource)) and (count(f:targetId) + count(f:url) + count(f:params) =1) or (f:type/f:code/@value='capabilities' or f:type/f:code/@value='search' or f:type/f:code/@value='transaction' or f:type/f:code/@value='history')"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/ValueSet",
"resource": {
"resourceType": "StructureDefinition",
"id": "ValueSet",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints ValueSet I DomainResource A set of codes drawn from one or more code systems
+ Value set SHALL contain at least one of a compose or an expansion element
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension url Σ 0..1 uri Logical URI to reference this value set (globally unique) identifier Σ 0..* Identifier Additional identifier for the value set
version Σ 0..1 string Business version of the value set name Σ 0..1 string Name for this value set (computer friendly) title Σ 0..1 string Name for this value set (human friendly) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) experimental ?!Σ 0..1 boolean For testing purposes, not real usage date Σ 0..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) contact Σ 0..* ContactDetail Contact details for the publisher
description 0..1 markdown Natural language description of the value set useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for value set (if applicable)
Jurisdiction ValueSet (Extensible)
immutable Σ 0..1 boolean Indicates whether or not any change to the content logical definition may occur purpose 0..1 markdown Why this value set is defined copyright 0..1 markdown Use and/or publishing restrictions extensible Σ 0..1 boolean Whether this is intended to be used with an extensible binding compose I 0..1 BackboneElement Definition of the content of the value set (CLD) lockedDate Σ 0..1 date Fixed date for version-less references (transitive) inactive Σ 0..1 boolean Whether inactive codes are in the value set include ΣI 1..* BackboneElement Include one or more codes from a code system or other value set(s)
+ A value set with concepts or filters SHALL include a system
+ Cannot have both concept and filter
+ A value set include/exclude SHALL have a value set or a system
system ΣI 0..1 uri The system the codes come from version Σ 0..1 string Specific version of the code system referred to concept I 0..* BackboneElement A concept defined in the system
code 1..1 code Code or expression from system display 0..1 string Text to display for this code for this value set in this valueset designation 0..* BackboneElement Additional representations for this concept
language 0..1 code Human language of the designation
Common Languages (Extensible but limited to All Languages) use 0..1 Coding Details how this designation would be used
Designation Use (Extensible) value 1..1 string The text value for this designation filter ?!ΣI 0..* BackboneElement Select codes/concepts by their properties (including relationships)
property Σ 1..1 code A property defined by the code system op Σ 1..1 code = | is-a | descendent-of | is-not-a | regex | in | not-in | generalizes | exists
FilterOperator (Required) value Σ 1..1 code Code from the system, or regex criteria, or boolean value for exists valueSet ΣI 0..* uri Select only contents included in this value set
exclude I 0..* see include Explicitly exclude codes from a code system or other value sets
expansion I 0..1 BackboneElement Used when the value set is "expanded" identifier 1..1 uri Uniquely identifies this expansion timestamp 1..1 dateTime Time ValueSet expansion happened total 0..1 integer Total number of codes in the expansion offset 0..1 integer Offset at which this resource starts parameter 0..* BackboneElement Parameter that controlled the expansion process
name 1..1 string Name as assigned by the server value[x] 0..1 Value of the named parameter valueString string valueBoolean boolean valueInteger integer valueDecimal decimal valueUri uri valueCode code contains I 0..* BackboneElement Codes in the value set
+ SHALL have a code or a display
+ Must have a code if not abstract
+ Must have a system if a code is present
system 0..1 uri System value for the code abstract 0..1 boolean If user cannot select this entry inactive 0..1 boolean If concept is inactive in the code system version 0..1 string Version in which this code/display is defined code I 0..1 code Code - if blank, this is not a selectable code display I 0..1 string User display for the concept designation 0..* see designation Additional representations for this item
contains 0..* see contains Codes contained under this entry
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 5
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "vocab"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/ValueSet",
"name": "ValueSet",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Vocabulary)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/Vocab/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for ValueSet Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "define.xml2.0",
"uri": "http://www.cdisc.org/define-xml",
"name": "CDISC Define XML 2.0 metadata standard"
},
{
"identity": "objimpl",
"uri": "http://hl7.org/fhir/object-implementation",
"name": "Object Implementation Information"
}
],
"kind": "resource",
"abstract": false,
"type": "ValueSet",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"_baseDefinition": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-codegen-super",
"valueString": "MetadataResource"
}
]
},
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "ValueSet",
"path": "ValueSet",
"short": "A set of codes drawn from one or more code systems",
"definition": "A value set specifies a set of codes drawn from one or more code systems.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
},
{
"key": "vsd-5",
"severity": "error",
"human": "Value set SHALL contain at least one of a compose or an expansion element",
"expression": "compose.exists() or expansion.exists()",
"xpath": "exists(f:compose) or exists(f:expansion)"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "conformance.terminology"
}
]
},
{
"id": "ValueSet.id",
"path": "ValueSet.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "ValueSet.meta",
"path": "ValueSet.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "ValueSet.implicitRules",
"path": "ValueSet.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "ValueSet.language",
"path": "ValueSet.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "ValueSet.text",
"path": "ValueSet.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "ValueSet.contained",
"path": "ValueSet.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.extension",
"path": "ValueSet.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.modifierExtension",
"path": "ValueSet.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.url",
"path": "ValueSet.url",
"short": "Logical URI to reference this value set (globally unique)",
"definition": "An absolute URI that is used to identify this value set when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this value set is (or will be) published. The URL SHOULD include the major version of the value set. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the value set to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ValueSet.identifier",
"path": "ValueSet.identifier",
"short": "Additional identifier for the value set",
"definition": "A formal identifier that is used to identify this value set when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this value set outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "define.xml2.0",
"map": "Identifier part"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ValueSet.version",
"path": "ValueSet.version",
"short": "Business version of the value set",
"definition": "The identifier that is used to identify this version of the value set when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the value set author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different value set instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the value set with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "ValueSet.name",
"path": "ValueSet.name",
"short": "Name for this value set (computer friendly)",
"definition": "A natural language name identifying the value set. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly. A name should be provided unless the value set is a contained resource (e.g. an anonymous value set in a profile). Most registries will require a name.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "ValueSet.title",
"path": "ValueSet.title",
"short": "Name for this value set (human friendly)",
"definition": "A short, descriptive, user-friendly title for the value set.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "ValueSet.status",
"path": "ValueSet.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this value set. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of value sets that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired value set without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ValueSet.experimental",
"path": "ValueSet.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this value set is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of value set that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental value set in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level value set.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ValueSet.date",
"path": "ValueSet.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the value set was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the value set changes. (e.g. the 'content logical definition').",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the value set. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ValueSet.publisher",
"path": "ValueSet.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the value set.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the value set is the organization or individual primarily responsible for the maintenance and upkeep of the value set. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the value set. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the value set. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "ValueSet.contact",
"path": "ValueSet.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "ValueSet.description",
"path": "ValueSet.description",
"short": "Natural language description of the value set",
"definition": "A free text natural language description of the value set from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the value set was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the value set as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created). The description is not intended to describe the semantics of the Value Set - there are no intrinsic semantics separate from the codes contained in its expansion. The description should capture its intended use, which is needed for ensuring integrity for its use in models across future changes. A description should be provided unless the value set is a contained resource (e.g. an anonymous value set in a profile). Most registries will require a description.",
"alias": [
"Scope",
"Purpose"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.useContext",
"path": "ValueSet.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate value set instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "ValueSet.jurisdiction",
"path": "ValueSet.jurisdiction",
"short": "Intended jurisdiction for value set (if applicable)",
"definition": "A legal or geographic region in which the value set is intended to be used.",
"comment": "It may be possible for the value set to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "ValueSet.immutable",
"path": "ValueSet.immutable",
"short": "Indicates whether or not any change to the content logical definition may occur",
"definition": "If this is set to 'true', then no new versions of the content logical definition can be created. Note: Other metadata might still change.",
"comment": "Normally immutability is set to 'false', which is the default assumption if it is not populated. Note that the implication is that if this is set to 'true', there may be only one ValueSet version for this definition. Immutability tends to be set to 'true' in one of two cases: - Where the value set, by the nature of its usage, cannot change. For example \"All specializations of ACT in ActClassCode\" - Where there's no safe way to express the \"Purpose\" such that someone else could safely make changes to the value set definition. Source workflow control must guarantee that the same URI always yields the same definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "ValueSet.purpose",
"path": "ValueSet.purpose",
"short": "Why this value set is defined",
"definition": "Explaination of why this value set is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the value set Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this value set.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ValueSet.copyright",
"path": "ValueSet.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the value set and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the value set.",
"comment": "null Frequently, the copyright differs between the value set and the codes that are included. The copyright statement should clearly differentiate between these when required.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the value set and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "ValueSet.extensible",
"path": "ValueSet.extensible",
"short": "Whether this is intended to be used with an extensible binding",
"definition": "Whether this is intended to be used with an extensible binding or not.",
"requirements": "It is not required to say whether this intent applies.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "ValueSet.compose",
"path": "ValueSet.compose",
"short": "Definition of the content of the value set (CLD)",
"definition": "A set of criteria that define the content logical definition of the value set by including or excluding codes from outside this value set. This I also known as the \"Content Logical Definition\" (CLD).",
"alias": [
"Content Logical Definition"
],
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"vsd-5"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "ValueSet.compose.id",
"path": "ValueSet.compose.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.compose.extension",
"path": "ValueSet.compose.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.compose.modifierExtension",
"path": "ValueSet.compose.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.lockedDate",
"path": "ValueSet.compose.lockedDate",
"short": "Fixed date for version-less references (transitive)",
"definition": "If a locked date is defined, then the Content Logical Definition must be evaluated using the current version as of the locked date for referenced code system(s) and value set instances where ValueSet.compose.include.version is not defined.",
"comment": "With a defined lockedDate the value set is considered \"Locked\". Otherwise, the value set may have different expansions as underlying code systems and/or value sets evolve. The interpretation of lockedDate is often dependent on the context - e.g. a SNOMED CT derived value set with a lockedDate will have a different expansion in USA than in UK. If a value set specifies a version for include and exclude statements, and also specifies a locked date, the specified versions need to be available that date, or the value set will not be usable.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.init"
}
]
},
{
"id": "ValueSet.compose.inactive",
"path": "ValueSet.compose.inactive",
"short": "Whether inactive codes are in the value set",
"definition": "Whether inactive codes - codes that are not approved for current use - are in the value set. If inactive = true, inactive codes are to be included in the expansion, if inactive = false, the inactive codes will not be included in the expansion. If absent, the behavior is determined by the implementation, or by the applicable ExpansionProfile (but generally, inactive codes would be expected to be included).",
"comment": "Note that in the FHIR terminology framework, \"deprecated\" does not mean inactive, but in some code systems (e.g. LOINC, deprecated means inactive). Code systems should define what codes are considered to be inactive. If this is not clearly defined (including in the FHIR code system resource), then all codes are assumed to be active.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "ValueSet.compose.include",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ConceptSet"
}
],
"path": "ValueSet.compose.include",
"short": "Include one or more codes from a code system or other value set(s)",
"definition": "Include one or more codes from a code system or other value set(s).",
"comment": "All the conditions in an include must be true. If a system is listed, all the codes from the system are listed. If one or more filters are listed, all of the filters must apply. If one or more value sets are listed, the codes must be in all the value sets. E.g. each include is 'include all the codes that meet all these conditions'.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "vsd-2",
"severity": "error",
"human": "A value set with concepts or filters SHALL include a system",
"expression": "(concept.exists() or filter.exists()) implies system.exists()",
"xpath": "not(exists(f:concept) or exists(f:filter)) or exists(f:system)"
},
{
"key": "vsd-3",
"severity": "error",
"human": "Cannot have both concept and filter",
"expression": "concept.empty() or filter.empty()",
"xpath": "not(exists(f:concept)) or not(exists(f:filter))"
},
{
"key": "vsd-1",
"severity": "error",
"human": "A value set include/exclude SHALL have a value set or a system",
"expression": "valueSet.exists() or system.exists()",
"xpath": "exists(f:valueSet) or exists(f:system)"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.id",
"path": "ValueSet.compose.include.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.compose.include.extension",
"path": "ValueSet.compose.include.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.compose.include.modifierExtension",
"path": "ValueSet.compose.include.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.system",
"path": "ValueSet.compose.include.system",
"short": "The system the codes come from",
"definition": "An absolute URI which is the code system from which the selected codes come from.",
"comment": "If there are no codes or filters, the entire code system is included. Note that the set of codes that are included may contain abstract codes. See ''Coding.system'' for further documentation about the correct value for the system element.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"condition": [
"vsd-1",
"vsd-2"
],
"isSummary": true,
"mapping": [
{
"identity": "define.xml2.0",
"map": "ODM/Study/MetaDataVersion/CodeList/ExternalCodeList/Href"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.version",
"path": "ValueSet.compose.include.version",
"short": "Specific version of the code system referred to",
"definition": "The version of the code system that the codes are selected from.",
"comment": "This is used when selecting the descendants of a concept - they may change between versions. If no version is specified, then the exact contents of the value set may not be known until a context of use binds it to a particular version.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "define.xml2.0",
"map": "ODM/Study/MetaDataVersion/CodeList/ExternalCodeList/Version"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.concept",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ConceptReference"
}
],
"path": "ValueSet.compose.include.concept",
"short": "A concept defined in the system",
"definition": "Specifies a concept to be included or excluded.",
"comment": "The list of concepts is considered ordered, though the order may not have any particular significance. Typically, the order of an expansion follows that defined in the compose element.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"vsd-3"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.concept.id",
"path": "ValueSet.compose.include.concept.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.compose.include.concept.extension",
"path": "ValueSet.compose.include.concept.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.compose.include.concept.modifierExtension",
"path": "ValueSet.compose.include.concept.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.concept.code",
"path": "ValueSet.compose.include.concept.code",
"short": "Code or expression from system",
"definition": "Specifies a code for the concept to be included or excluded.",
"comment": "Expressions are allowed if defined by the underlying code system.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.concept.display",
"path": "ValueSet.compose.include.concept.display",
"short": "Text to display for this code for this value set in this valueset",
"definition": "The text to display to the user for this concept in the context of this valueset. If no display is provided, then applications using the value set use the display specified for the code by the system.",
"comment": "The value set resource allows for an alternative display to be specified for when this concept is used in this particular value set. See notes in the value set narrative about the correct use of this element.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.concept.designation",
"path": "ValueSet.compose.include.concept.designation",
"short": "Additional representations for this concept",
"definition": "Additional representations for this concept when used in this value set - other languages, aliases, specialized purposes, used for particular purposes, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "ValueSet.compose.include.concept.designation.id",
"path": "ValueSet.compose.include.concept.designation.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.compose.include.concept.designation.extension",
"path": "ValueSet.compose.include.concept.designation.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.compose.include.concept.designation.modifierExtension",
"path": "ValueSet.compose.include.concept.designation.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.concept.designation.language",
"path": "ValueSet.compose.include.concept.designation.language",
"short": "Human language of the designation",
"definition": "The language this designation is defined for.",
"comment": "In the absence of a language, the resource language applies.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "ValueSet.compose.include.concept.designation.use",
"path": "ValueSet.compose.include.concept.designation.use",
"short": "Details how this designation would be used",
"definition": "A code that details how this designation would be used.",
"comment": "If no use is provided, the designation can be assumed to be suitable for general display to a human user.",
"min": 0,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ConceptDesignationUse"
}
],
"strength": "extensible",
"description": "Details of how a designation would be used.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/designation-use"
}
}
},
{
"id": "ValueSet.compose.include.concept.designation.value",
"path": "ValueSet.compose.include.concept.designation.value",
"short": "The text value for this designation",
"definition": "The text value for this designation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ValueSet.compose.include.filter",
"path": "ValueSet.compose.include.filter",
"short": "Select codes/concepts by their properties (including relationships)",
"definition": "Select concepts by specify a matching criteria based on the properties (including relationships) defined by the system. If multiple filters are specified, they SHALL all be true.",
"comment": "Selecting codes by specifying filters based on properties is only possible where the underlying code system defines appropriate properties. Note that in some cases, the underlying code system defines the logical concepts but not the literal codes for the concepts. In such cases, the literal definitions may be provided by a third party.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"vsd-3"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.filter.id",
"path": "ValueSet.compose.include.filter.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.compose.include.filter.extension",
"path": "ValueSet.compose.include.filter.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.compose.include.filter.modifierExtension",
"path": "ValueSet.compose.include.filter.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.filter.property",
"path": "ValueSet.compose.include.filter.property",
"short": "A property defined by the code system",
"definition": "A code that identifies a property defined in the code system.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.filter.op",
"path": "ValueSet.compose.include.filter.op",
"short": "= | is-a | descendent-of | is-not-a | regex | in | not-in | generalizes | exists",
"definition": "The kind of operation to perform as a part of the filter criteria.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FilterOperator"
}
],
"strength": "required",
"description": "The kind of operation to perform as a part of a property based filter.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/filter-operator"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.filter.value",
"path": "ValueSet.compose.include.filter.value",
"short": "Code from the system, or regex criteria, or boolean value for exists",
"definition": "The match value may be either a code defined by the system, or a string value, which is a regex match on the literal string of the property value when the operation is 'regex', or one of the values (true and false), when the operation is 'exists'.",
"comment": "Use regex matching with care - full regex matching on every SNOMED CT term is prohibitive, for example.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.valueSet",
"path": "ValueSet.compose.include.valueSet",
"short": "Select only contents included in this value set",
"definition": "Selects concepts found in this value set. This is an absolute URI that is a reference to ValueSet.url.",
"comment": "The value set URI is either a logical reference to a defined value set such as a [SNOMED CT reference set]{snomedct.html#implicit}, or a direct reference to a value set definition using ValueSet.url. The reference may not refer to an actual FHIR ValueSet resource; in this case, whatever is referred to is an implicit definition of a value set that needs to be clear about how versions are resolved.",
"min": 0,
"max": "*",
"type": [
{
"code": "uri"
}
],
"condition": [
"vsd-1"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.exclude",
"path": "ValueSet.compose.exclude",
"short": "Explicitly exclude codes from a code system or other value sets",
"definition": "Exclude one or more codes from the value set based on code system filters and/or other value sets.",
"comment": "Usually this is used to selectively exclude codes that were included by subsumption in the inclusions. Any display names specified for the codes are ignored.",
"min": 0,
"max": "*",
"contentReference": "#ValueSet.compose.include",
"condition": [
"vsd-2"
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.expansion",
"path": "ValueSet.expansion",
"short": "Used when the value set is \"expanded\"",
"definition": "A value set can also be \"expanded\", where the value set is turned into a simple collection of enumerated codes. This element holds the expansion, if it has been performed.",
"comment": "Expansion is performed to produce a collection of codes that are ready to use for data entry or validation.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"vsd-5"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "ValueSet.expansion.id",
"path": "ValueSet.expansion.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.expansion.extension",
"path": "ValueSet.expansion.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.expansion.modifierExtension",
"path": "ValueSet.expansion.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.expansion.identifier",
"path": "ValueSet.expansion.identifier",
"short": "Uniquely identifies this expansion",
"definition": "An identifier that uniquely identifies this expansion of the valueset. Systems may re-use the same identifier as long as the expansion and the definition remain the same, but are not required to do so.",
"comment": "Typically, this uri is a UUID (e.g. urn:uuid:8230ff20-c97a-4167-a59d-dc2cb9df16dd).",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "ValueSet.expansion.timestamp",
"path": "ValueSet.expansion.timestamp",
"short": "Time ValueSet expansion happened",
"definition": "The time at which the expansion was produced by the expanding system.",
"comment": "This SHOULD be a fully populated instant, but in some circumstances, value sets are expanded by hand, and the expansion is published without that precision.",
"min": 1,
"max": "1",
"type": [
{
"code": "dateTime"
}
]
},
{
"id": "ValueSet.expansion.total",
"path": "ValueSet.expansion.total",
"short": "Total number of codes in the expansion",
"definition": "The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter.",
"comment": "Paging only applies to flat expansions.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "ValueSet.expansion.offset",
"path": "ValueSet.expansion.offset",
"short": "Offset at which this resource starts",
"definition": "If paging is being used, the offset at which this resource starts. I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL not be present.",
"comment": "Paging only applies to flat expansions. If a filter is applied, the count is the number of concepts that matched the filter, not the number of concepts in an unfiltered view of the expansion.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"meaningWhenMissing": "Paging is not being used"
},
{
"id": "ValueSet.expansion.parameter",
"path": "ValueSet.expansion.parameter",
"short": "Parameter that controlled the expansion process",
"definition": "A parameter that controlled the expansion process. These parameters may be used by users of expanded value sets to check whether the expansion is suitable for a particular purpose, or to pick the correct expansion.",
"comment": "The server decides which parameters to include here, but at a minimum, the list SHOULD include the date, filter, and profile parameters passed to the $expand operation (if any).",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
]
},
{
"id": "ValueSet.expansion.parameter.id",
"path": "ValueSet.expansion.parameter.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.expansion.parameter.extension",
"path": "ValueSet.expansion.parameter.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.expansion.parameter.modifierExtension",
"path": "ValueSet.expansion.parameter.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.expansion.parameter.name",
"path": "ValueSet.expansion.parameter.name",
"short": "Name as assigned by the server",
"definition": "The name of the parameter.",
"comment": "The names are assigned at the discretion of the server.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ValueSet.expansion.parameter.value[x]",
"path": "ValueSet.expansion.parameter.value[x]",
"short": "Value of the named parameter",
"definition": "The value of the parameter.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
},
{
"code": "boolean"
},
{
"code": "integer"
},
{
"code": "decimal"
},
{
"code": "uri"
},
{
"code": "code"
}
]
},
{
"id": "ValueSet.expansion.contains",
"path": "ValueSet.expansion.contains",
"short": "Codes in the value set",
"definition": "The codes that are contained in the value set expansion.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
},
{
"key": "vsd-6",
"severity": "error",
"human": "SHALL have a code or a display",
"expression": "code.exists() or display.exists()",
"xpath": "exists(f:code) or exists(f:display)"
},
{
"key": "vsd-9",
"severity": "error",
"human": "Must have a code if not abstract",
"expression": "code.exists() or abstract = true",
"xpath": "exists(f:code) or (f:abstract/@value = true())"
},
{
"key": "vsd-10",
"severity": "error",
"human": "Must have a system if a code is present",
"expression": "code.empty() or system.exists()",
"xpath": "exists(f:system) or not(exists(f:code))"
}
]
},
{
"id": "ValueSet.expansion.contains.id",
"path": "ValueSet.expansion.contains.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.expansion.contains.extension",
"path": "ValueSet.expansion.contains.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "ValueSet.expansion.contains.modifierExtension",
"path": "ValueSet.expansion.contains.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.expansion.contains.system",
"path": "ValueSet.expansion.contains.system",
"short": "System value for the code",
"definition": "An absolute URI which is the code system in which the code for this item in the expansion is defined.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "ValueSet.expansion.contains.abstract",
"path": "ValueSet.expansion.contains.abstract",
"short": "If user cannot select this entry",
"definition": "If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value.",
"comment": "This should not be understood to exclude its use for searching (e.g. by subsumption testing). The client should know whether it is appropriate for the user to select an abstract code or not.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "ValueSet.expansion.contains.inactive",
"path": "ValueSet.expansion.contains.inactive",
"short": "If concept is inactive in the code system",
"definition": "If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data.",
"comment": "This should only have a value if the concept is inactive.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "ValueSet.expansion.contains.version",
"path": "ValueSet.expansion.contains.version",
"short": "Version in which this code/display is defined",
"definition": "The version of this code system that defined this code and/or display. This should only be used with code systems that do not enforce concept permanence.",
"comment": "The exact value of the version string is specified by the system from which the code is derived.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ValueSet.expansion.contains.code",
"path": "ValueSet.expansion.contains.code",
"short": "Code - if blank, this is not a selectable code",
"definition": "The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"vsd-6"
]
},
{
"id": "ValueSet.expansion.contains.display",
"path": "ValueSet.expansion.contains.display",
"short": "User display for the concept",
"definition": "The recommended display for this item in the expansion.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"vsd-6"
]
},
{
"id": "ValueSet.expansion.contains.designation",
"path": "ValueSet.expansion.contains.designation",
"short": "Additional representations for this item",
"definition": "Additional representations for this item - other languages, aliases, specialized purposes, used for particular purposes, etc. These are relevant when the conditions of the expansion do not fix to a single correct representation.",
"comment": "The designations provided must be based on the value set and code system definitions.",
"min": 0,
"max": "*",
"contentReference": "#ValueSet.compose.include.concept.designation"
},
{
"id": "ValueSet.expansion.contains.contains",
"path": "ValueSet.expansion.contains.contains",
"short": "Codes contained under this entry",
"definition": "Other codes and entries contained under this entry in the hierarchy.",
"comment": "If the expansion uses this element, there is no implication about the logical relationship between them, and the structure cannot be used for logical inferencing. The structure exists to provide navigational assistance for helping human users to locate codes in the expansion.",
"min": 0,
"max": "*",
"contentReference": "#ValueSet.expansion.contains"
}
]
},
"differential": {
"element": [
{
"id": "ValueSet",
"path": "ValueSet",
"short": "A set of codes drawn from one or more code systems",
"definition": "A value set specifies a set of codes drawn from one or more code systems.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "vsd-5",
"severity": "error",
"human": "Value set SHALL contain at least one of a compose or an expansion element",
"expression": "compose.exists() or expansion.exists()",
"xpath": "exists(f:compose) or exists(f:expansion)"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "conformance.terminology"
}
]
},
{
"id": "ValueSet.url",
"path": "ValueSet.url",
"short": "Logical URI to reference this value set (globally unique)",
"definition": "An absolute URI that is used to identify this value set when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this value set is (or will be) published. The URL SHOULD include the major version of the value set. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the value set to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ValueSet.identifier",
"path": "ValueSet.identifier",
"short": "Additional identifier for the value set",
"definition": "A formal identifier that is used to identify this value set when it is represented in other formats, or referenced in a specification, model, design or an instance.",
"comment": "Typically, this is used for identifiers that can go in an HL7 V3 II (instance identifier) data type, e.g., to identify this value set outside of FHIR, where it is not possible to use the logical URI.",
"requirements": "Allows externally provided and/or usable business identifiers to be easily associated with the module.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"isSummary": true,
"mapping": [
{
"identity": "define.xml2.0",
"map": "Identifier part"
},
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "ValueSet.version",
"path": "ValueSet.version",
"short": "Business version of the value set",
"definition": "The identifier that is used to identify this version of the value set when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the value set author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different value set instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the value set with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "ValueSet.name",
"path": "ValueSet.name",
"short": "Name for this value set (computer friendly)",
"definition": "A natural language name identifying the value set. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly. A name should be provided unless the value set is a contained resource (e.g. an anonymous value set in a profile). Most registries will require a name.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "ValueSet.title",
"path": "ValueSet.title",
"short": "Name for this value set (human friendly)",
"definition": "A short, descriptive, user-friendly title for the value set.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "ValueSet.status",
"path": "ValueSet.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this value set. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of value sets that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired value set without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "ValueSet.experimental",
"path": "ValueSet.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this value set is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of value set that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental value set in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level value set.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "ValueSet.date",
"path": "ValueSet.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the value set was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the value set changes. (e.g. the 'content logical definition').",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the value set. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "ValueSet.publisher",
"path": "ValueSet.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the value set.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the value set is the organization or individual primarily responsible for the maintenance and upkeep of the value set. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the value set. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the value set. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "ValueSet.contact",
"path": "ValueSet.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "ValueSet.description",
"path": "ValueSet.description",
"short": "Natural language description of the value set",
"definition": "A free text natural language description of the value set from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the value set was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the value set as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created). The description is not intended to describe the semantics of the Value Set - there are no intrinsic semantics separate from the codes contained in its expansion. The description should capture its intended use, which is needed for ensuring integrity for its use in models across future changes. A description should be provided unless the value set is a contained resource (e.g. an anonymous value set in a profile). Most registries will require a description.",
"alias": [
"Scope",
"Purpose"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.useContext",
"path": "ValueSet.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate value set instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "ValueSet.jurisdiction",
"path": "ValueSet.jurisdiction",
"short": "Intended jurisdiction for value set (if applicable)",
"definition": "A legal or geographic region in which the value set is intended to be used.",
"comment": "It may be possible for the value set to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "ValueSet.immutable",
"path": "ValueSet.immutable",
"short": "Indicates whether or not any change to the content logical definition may occur",
"definition": "If this is set to 'true', then no new versions of the content logical definition can be created. Note: Other metadata might still change.",
"comment": "Normally immutability is set to 'false', which is the default assumption if it is not populated. Note that the implication is that if this is set to 'true', there may be only one ValueSet version for this definition. Immutability tends to be set to 'true' in one of two cases: - Where the value set, by the nature of its usage, cannot change. For example \"All specializations of ACT in ActClassCode\" - Where there's no safe way to express the \"Purpose\" such that someone else could safely make changes to the value set definition. Source workflow control must guarantee that the same URI always yields the same definition.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "ValueSet.purpose",
"path": "ValueSet.purpose",
"short": "Why this value set is defined",
"definition": "Explaination of why this value set is needed and why it has been designed as it has.",
"comment": "This element does not describe the usage of the value set Instead it provides traceability of ''why'' the resource is either needed or ''why'' it is defined as it is. This may be used to point to source materials or specifications that drove the structure of this value set.",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "ValueSet.copyright",
"path": "ValueSet.copyright",
"short": "Use and/or publishing restrictions",
"definition": "A copyright statement relating to the value set and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the value set.",
"comment": "null Frequently, the copyright differs between the value set and the codes that are included. The copyright statement should clearly differentiate between these when required.",
"requirements": "Consumers must be able to determine any legal restrictions on the use of the value set and/or its content.",
"alias": [
"License",
"Restrictions"
],
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
],
"mapping": [
{
"identity": "objimpl",
"map": "no-gen-base"
}
]
},
{
"id": "ValueSet.extensible",
"path": "ValueSet.extensible",
"short": "Whether this is intended to be used with an extensible binding",
"definition": "Whether this is intended to be used with an extensible binding or not.",
"requirements": "It is not required to say whether this intent applies.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "ValueSet.compose",
"path": "ValueSet.compose",
"short": "Definition of the content of the value set (CLD)",
"definition": "A set of criteria that define the content logical definition of the value set by including or excluding codes from outside this value set. This I also known as the \"Content Logical Definition\" (CLD).",
"alias": [
"Content Logical Definition"
],
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"vsd-5"
]
},
{
"id": "ValueSet.compose.lockedDate",
"path": "ValueSet.compose.lockedDate",
"short": "Fixed date for version-less references (transitive)",
"definition": "If a locked date is defined, then the Content Logical Definition must be evaluated using the current version as of the locked date for referenced code system(s) and value set instances where ValueSet.compose.include.version is not defined.",
"comment": "With a defined lockedDate the value set is considered \"Locked\". Otherwise, the value set may have different expansions as underlying code systems and/or value sets evolve. The interpretation of lockedDate is often dependent on the context - e.g. a SNOMED CT derived value set with a lockedDate will have a different expansion in USA than in UK. If a value set specifies a version for include and exclude statements, and also specifies a locked date, the specified versions need to be available that date, or the value set will not be usable.",
"min": 0,
"max": "1",
"type": [
{
"code": "date"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.init"
}
]
},
{
"id": "ValueSet.compose.inactive",
"path": "ValueSet.compose.inactive",
"short": "Whether inactive codes are in the value set",
"definition": "Whether inactive codes - codes that are not approved for current use - are in the value set. If inactive = true, inactive codes are to be included in the expansion, if inactive = false, the inactive codes will not be included in the expansion. If absent, the behavior is determined by the implementation, or by the applicable ExpansionProfile (but generally, inactive codes would be expected to be included).",
"comment": "Note that in the FHIR terminology framework, \"deprecated\" does not mean inactive, but in some code systems (e.g. LOINC, deprecated means inactive). Code systems should define what codes are considered to be inactive. If this is not clearly defined (including in the FHIR code system resource), then all codes are assumed to be active.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isSummary": true
},
{
"id": "ValueSet.compose.include",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ConceptSet"
}
],
"path": "ValueSet.compose.include",
"short": "Include one or more codes from a code system or other value set(s)",
"definition": "Include one or more codes from a code system or other value set(s).",
"comment": "All the conditions in an include must be true. If a system is listed, all the codes from the system are listed. If one or more filters are listed, all of the filters must apply. If one or more value sets are listed, the codes must be in all the value sets. E.g. each include is 'include all the codes that meet all these conditions'.",
"min": 1,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "vsd-2",
"severity": "error",
"human": "A value set with concepts or filters SHALL include a system",
"expression": "(concept.exists() or filter.exists()) implies system.exists()",
"xpath": "not(exists(f:concept) or exists(f:filter)) or exists(f:system)"
},
{
"key": "vsd-3",
"severity": "error",
"human": "Cannot have both concept and filter",
"expression": "concept.empty() or filter.empty()",
"xpath": "not(exists(f:concept)) or not(exists(f:filter))"
},
{
"key": "vsd-1",
"severity": "error",
"human": "A value set include/exclude SHALL have a value set or a system",
"expression": "valueSet.exists() or system.exists()",
"xpath": "exists(f:valueSet) or exists(f:system)"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.system",
"path": "ValueSet.compose.include.system",
"short": "The system the codes come from",
"definition": "An absolute URI which is the code system from which the selected codes come from.",
"comment": "If there are no codes or filters, the entire code system is included. Note that the set of codes that are included may contain abstract codes. See ''Coding.system'' for further documentation about the correct value for the system element.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"condition": [
"vsd-1",
"vsd-2"
],
"isSummary": true,
"mapping": [
{
"identity": "define.xml2.0",
"map": "ODM/Study/MetaDataVersion/CodeList/ExternalCodeList/Href"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.version",
"path": "ValueSet.compose.include.version",
"short": "Specific version of the code system referred to",
"definition": "The version of the code system that the codes are selected from.",
"comment": "This is used when selecting the descendants of a concept - they may change between versions. If no version is specified, then the exact contents of the value set may not be known until a context of use binds it to a particular version.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "define.xml2.0",
"map": "ODM/Study/MetaDataVersion/CodeList/ExternalCodeList/Version"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.concept",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-explicit-type-name",
"valueString": "ConceptReference"
}
],
"path": "ValueSet.compose.include.concept",
"short": "A concept defined in the system",
"definition": "Specifies a concept to be included or excluded.",
"comment": "The list of concepts is considered ordered, though the order may not have any particular significance. Typically, the order of an expansion follows that defined in the compose element.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"vsd-3"
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.concept.code",
"path": "ValueSet.compose.include.concept.code",
"short": "Code or expression from system",
"definition": "Specifies a code for the concept to be included or excluded.",
"comment": "Expressions are allowed if defined by the underlying code system.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.concept.display",
"path": "ValueSet.compose.include.concept.display",
"short": "Text to display for this code for this value set in this valueset",
"definition": "The text to display to the user for this concept in the context of this valueset. If no display is provided, then applications using the value set use the display specified for the code by the system.",
"comment": "The value set resource allows for an alternative display to be specified for when this concept is used in this particular value set. See notes in the value set narrative about the correct use of this element.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.concept.designation",
"path": "ValueSet.compose.include.concept.designation",
"short": "Additional representations for this concept",
"definition": "Additional representations for this concept when used in this value set - other languages, aliases, specialized purposes, used for particular purposes, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "ValueSet.compose.include.concept.designation.language",
"path": "ValueSet.compose.include.concept.designation.language",
"short": "Human language of the designation",
"definition": "The language this designation is defined for.",
"comment": "In the absence of a language, the resource language applies.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "ValueSet.compose.include.concept.designation.use",
"path": "ValueSet.compose.include.concept.designation.use",
"short": "Details how this designation would be used",
"definition": "A code that details how this designation would be used.",
"comment": "If no use is provided, the designation can be assumed to be suitable for general display to a human user.",
"min": 0,
"max": "1",
"type": [
{
"code": "Coding"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "ConceptDesignationUse"
}
],
"strength": "extensible",
"description": "Details of how a designation would be used.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/designation-use"
}
}
},
{
"id": "ValueSet.compose.include.concept.designation.value",
"path": "ValueSet.compose.include.concept.designation.value",
"short": "The text value for this designation",
"definition": "The text value for this designation.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ValueSet.compose.include.filter",
"path": "ValueSet.compose.include.filter",
"short": "Select codes/concepts by their properties (including relationships)",
"definition": "Select concepts by specify a matching criteria based on the properties (including relationships) defined by the system. If multiple filters are specified, they SHALL all be true.",
"comment": "Selecting codes by specifying filters based on properties is only possible where the underlying code system defines appropriate properties. Note that in some cases, the underlying code system defines the logical concepts but not the literal codes for the concepts. In such cases, the literal definitions may be provided by a third party.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"vsd-3"
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.filter.property",
"path": "ValueSet.compose.include.filter.property",
"short": "A property defined by the code system",
"definition": "A code that identifies a property defined in the code system.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.filter.op",
"path": "ValueSet.compose.include.filter.op",
"short": "= | is-a | descendent-of | is-not-a | regex | in | not-in | generalizes | exists",
"definition": "The kind of operation to perform as a part of the filter criteria.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "FilterOperator"
}
],
"strength": "required",
"description": "The kind of operation to perform as a part of a property based filter.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/filter-operator"
}
},
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.filter.value",
"path": "ValueSet.compose.include.filter.value",
"short": "Code from the system, or regex criteria, or boolean value for exists",
"definition": "The match value may be either a code defined by the system, or a string value, which is a regex match on the literal string of the property value when the operation is 'regex', or one of the values (true and false), when the operation is 'exists'.",
"comment": "Use regex matching with care - full regex matching on every SNOMED CT term is prohibitive, for example.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.include.valueSet",
"path": "ValueSet.compose.include.valueSet",
"short": "Select only contents included in this value set",
"definition": "Selects concepts found in this value set. This is an absolute URI that is a reference to ValueSet.url.",
"comment": "The value set URI is either a logical reference to a defined value set such as a [SNOMED CT reference set]{snomedct.html#implicit}, or a direct reference to a value set definition using ValueSet.url. The reference may not refer to an actual FHIR ValueSet resource; in this case, whatever is referred to is an implicit definition of a value set that needs to be clear about how versions are resolved.",
"min": 0,
"max": "*",
"type": [
{
"code": "uri"
}
],
"condition": [
"vsd-1"
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.compose.exclude",
"path": "ValueSet.compose.exclude",
"short": "Explicitly exclude codes from a code system or other value sets",
"definition": "Exclude one or more codes from the value set based on code system filters and/or other value sets.",
"comment": "Usually this is used to selectively exclude codes that were included by subsumption in the inclusions. Any display names specified for the codes are ignored.",
"min": 0,
"max": "*",
"contentReference": "#ValueSet.compose.include",
"condition": [
"vsd-2"
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "ValueSet.expansion",
"path": "ValueSet.expansion",
"short": "Used when the value set is \"expanded\"",
"definition": "A value set can also be \"expanded\", where the value set is turned into a simple collection of enumerated codes. This element holds the expansion, if it has been performed.",
"comment": "Expansion is performed to produce a collection of codes that are ready to use for data entry or validation.",
"min": 0,
"max": "1",
"type": [
{
"code": "BackboneElement"
}
],
"condition": [
"vsd-5"
]
},
{
"id": "ValueSet.expansion.identifier",
"path": "ValueSet.expansion.identifier",
"short": "Uniquely identifies this expansion",
"definition": "An identifier that uniquely identifies this expansion of the valueset. Systems may re-use the same identifier as long as the expansion and the definition remain the same, but are not required to do so.",
"comment": "Typically, this uri is a UUID (e.g. urn:uuid:8230ff20-c97a-4167-a59d-dc2cb9df16dd).",
"min": 1,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "ValueSet.expansion.timestamp",
"path": "ValueSet.expansion.timestamp",
"short": "Time ValueSet expansion happened",
"definition": "The time at which the expansion was produced by the expanding system.",
"comment": "This SHOULD be a fully populated instant, but in some circumstances, value sets are expanded by hand, and the expansion is published without that precision.",
"min": 1,
"max": "1",
"type": [
{
"code": "dateTime"
}
]
},
{
"id": "ValueSet.expansion.total",
"path": "ValueSet.expansion.total",
"short": "Total number of codes in the expansion",
"definition": "The total number of concepts in the expansion. If the number of concept nodes in this resource is less than the stated number, then the server can return more using the offset parameter.",
"comment": "Paging only applies to flat expansions.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "ValueSet.expansion.offset",
"path": "ValueSet.expansion.offset",
"short": "Offset at which this resource starts",
"definition": "If paging is being used, the offset at which this resource starts. I.e. this resource is a partial view into the expansion. If paging is not being used, this element SHALL not be present.",
"comment": "Paging only applies to flat expansions. If a filter is applied, the count is the number of concepts that matched the filter, not the number of concepts in an unfiltered view of the expansion.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
],
"meaningWhenMissing": "Paging is not being used"
},
{
"id": "ValueSet.expansion.parameter",
"path": "ValueSet.expansion.parameter",
"short": "Parameter that controlled the expansion process",
"definition": "A parameter that controlled the expansion process. These parameters may be used by users of expanded value sets to check whether the expansion is suitable for a particular purpose, or to pick the correct expansion.",
"comment": "The server decides which parameters to include here, but at a minimum, the list SHOULD include the date, filter, and profile parameters passed to the $expand operation (if any).",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
]
},
{
"id": "ValueSet.expansion.parameter.name",
"path": "ValueSet.expansion.parameter.name",
"short": "Name as assigned by the server",
"definition": "The name of the parameter.",
"comment": "The names are assigned at the discretion of the server.",
"min": 1,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ValueSet.expansion.parameter.value[x]",
"path": "ValueSet.expansion.parameter.value[x]",
"short": "Value of the named parameter",
"definition": "The value of the parameter.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
},
{
"code": "boolean"
},
{
"code": "integer"
},
{
"code": "decimal"
},
{
"code": "uri"
},
{
"code": "code"
}
]
},
{
"id": "ValueSet.expansion.contains",
"path": "ValueSet.expansion.contains",
"short": "Codes in the value set",
"definition": "The codes that are contained in the value set expansion.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "vsd-6",
"severity": "error",
"human": "SHALL have a code or a display",
"expression": "code.exists() or display.exists()",
"xpath": "exists(f:code) or exists(f:display)"
},
{
"key": "vsd-9",
"severity": "error",
"human": "Must have a code if not abstract",
"expression": "code.exists() or abstract = true",
"xpath": "exists(f:code) or (f:abstract/@value = true())"
},
{
"key": "vsd-10",
"severity": "error",
"human": "Must have a system if a code is present",
"expression": "code.empty() or system.exists()",
"xpath": "exists(f:system) or not(exists(f:code))"
}
]
},
{
"id": "ValueSet.expansion.contains.system",
"path": "ValueSet.expansion.contains.system",
"short": "System value for the code",
"definition": "An absolute URI which is the code system in which the code for this item in the expansion is defined.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
]
},
{
"id": "ValueSet.expansion.contains.abstract",
"path": "ValueSet.expansion.contains.abstract",
"short": "If user cannot select this entry",
"definition": "If true, this entry is included in the expansion for navigational purposes, and the user cannot select the code directly as a proper value.",
"comment": "This should not be understood to exclude its use for searching (e.g. by subsumption testing). The client should know whether it is appropriate for the user to select an abstract code or not.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "ValueSet.expansion.contains.inactive",
"path": "ValueSet.expansion.contains.inactive",
"short": "If concept is inactive in the code system",
"definition": "If the concept is inactive in the code system that defines it. Inactive codes are those that are no longer to be used, but are maintained by the code system for understanding legacy data.",
"comment": "This should only have a value if the concept is inactive.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"defaultValueBoolean": false
},
{
"id": "ValueSet.expansion.contains.version",
"path": "ValueSet.expansion.contains.version",
"short": "Version in which this code/display is defined",
"definition": "The version of this code system that defined this code and/or display. This should only be used with code systems that do not enforce concept permanence.",
"comment": "The exact value of the version string is specified by the system from which the code is derived.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "ValueSet.expansion.contains.code",
"path": "ValueSet.expansion.contains.code",
"short": "Code - if blank, this is not a selectable code",
"definition": "The code for this item in the expansion hierarchy. If this code is missing the entry in the hierarchy is a place holder (abstract) and does not represent a valid code in the value set.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"condition": [
"vsd-6"
]
},
{
"id": "ValueSet.expansion.contains.display",
"path": "ValueSet.expansion.contains.display",
"short": "User display for the concept",
"definition": "The recommended display for this item in the expansion.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"condition": [
"vsd-6"
]
},
{
"id": "ValueSet.expansion.contains.designation",
"path": "ValueSet.expansion.contains.designation",
"short": "Additional representations for this item",
"definition": "Additional representations for this item - other languages, aliases, specialized purposes, used for particular purposes, etc. These are relevant when the conditions of the expansion do not fix to a single correct representation.",
"comment": "The designations provided must be based on the value set and code system definitions.",
"min": 0,
"max": "*",
"contentReference": "#ValueSet.compose.include.concept.designation"
},
{
"id": "ValueSet.expansion.contains.contains",
"path": "ValueSet.expansion.contains.contains",
"short": "Codes contained under this entry",
"definition": "Other codes and entries contained under this entry in the hierarchy.",
"comment": "If the expansion uses this element, there is no implication about the logical relationship between them, and the structure cannot be used for logical inferencing. The structure exists to provide navigational assistance for helping human users to locate codes in the expansion.",
"min": 0,
"max": "*",
"contentReference": "#ValueSet.expansion.contains"
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/VisionPrescription",
"resource": {
"resourceType": "StructureDefinition",
"id": "VisionPrescription",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints VisionPrescription DomainResource Prescription for vision correction products for a patient
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension identifier 0..* Identifier Business identifier
status ?!Σ 0..1 code active | cancelled | draft | entered-in-error
Financial Resource Status Codes (Required) patient 0..1 Reference(Patient) Who prescription is for encounter 0..1 Reference(Encounter) Created during encounter / admission / stay dateWritten 0..1 dateTime When prescription was authorized prescriber 0..1 Reference(Practitioner) Who authorizes the vision product reason[x] 0..1 Reason or indication for writing the prescription reasonCodeableConcept CodeableConcept reasonReference Reference(Condition) dispense 0..* BackboneElement Vision supply authorization
product 0..1 CodeableConcept Product to be supplied
Example Vision Prescription Product Codes (Example) eye 0..1 code right | left
VisionEyes (Required) sphere 0..1 decimal Lens sphere cylinder 0..1 decimal Lens cylinder axis 0..1 integer Lens axis prism 0..1 decimal Lens prism base 0..1 code up | down | in | out
VisionBase (Required) add 0..1 decimal Lens add power 0..1 decimal Contact lens power backCurve 0..1 decimal Contact lens back curvature diameter 0..1 decimal Contact lens diameter duration 0..1 SimpleQuantity Lens wear duration color 0..1 string Color required brand 0..1 string Brand required note 0..* Annotation Notes for coatings
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm",
"valueInteger": 1
},
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fm"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/VisionPrescription",
"name": "VisionPrescription",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (Financial Management)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fm/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for VisionPrescription Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "workflow",
"uri": "http://hl7.org/fhir/workflow",
"name": "Workflow Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
},
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "v2",
"uri": "http://hl7.org/v2",
"name": "HL7 v2 Mapping"
}
],
"kind": "resource",
"abstract": false,
"type": "VisionPrescription",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "VisionPrescription",
"path": "VisionPrescription",
"short": "Prescription for vision correction products for a patient",
"definition": "An authorization for the supply of glasses and/or contact lenses to a patient.",
"min": 0,
"max": "*",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "rim",
"map": "CombinedVisionRequest"
},
{
"identity": "w5",
"map": "clinical.careprovision"
}
]
},
{
"id": "VisionPrescription.id",
"path": "VisionPrescription.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "VisionPrescription.meta",
"path": "VisionPrescription.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "VisionPrescription.implicitRules",
"path": "VisionPrescription.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "VisionPrescription.language",
"path": "VisionPrescription.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "VisionPrescription.text",
"path": "VisionPrescription.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "VisionPrescription.contained",
"path": "VisionPrescription.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "VisionPrescription.extension",
"path": "VisionPrescription.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "VisionPrescription.modifierExtension",
"path": "VisionPrescription.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "VisionPrescription.identifier",
"path": "VisionPrescription.identifier",
"short": "Business identifier",
"definition": "Business identifier which may be used by other parties to reference or identify the prescription.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "v2",
"map": "ORC-2-Placer Order Number / ORC-3-Filler Order Number"
},
{
"identity": "rim",
"map": "id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "VisionPrescription.status",
"path": "VisionPrescription.status",
"short": "active | cancelled | draft | entered-in-error",
"definition": "The status of the resource instance.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "VisionStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the resource instance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/fm-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "VisionPrescription.patient",
"path": "VisionPrescription.patient",
"short": "Who prescription is for",
"definition": "A link to a resource representing the person to whom the vision products will be supplied.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.subject"
},
{
"identity": "v2",
"map": "PID-3-Patient ID List"
},
{
"identity": "rim",
"map": "subject.role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "VisionPrescription.encounter",
"path": "VisionPrescription.encounter",
"short": "Created during encounter / admission / stay",
"definition": "A link to a resource that identifies the particular occurrence of contact between patient and health care provider.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.context"
},
{
"identity": "v2",
"map": "PV1-19-Visit Number"
},
{
"identity": "rim",
"map": "componentOf.patientEncounter"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "VisionPrescription.dateWritten",
"path": "VisionPrescription.dateWritten",
"short": "When prescription was authorized",
"definition": "The date (and perhaps time) when the prescription was written.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "v2",
"map": "RXE-32-Original Order Date/Time / ORC-9-Date/Time of Transaction"
},
{
"identity": "rim",
"map": "author.time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "VisionPrescription.prescriber",
"path": "VisionPrescription.prescriber",
"short": "Who authorizes the vision product",
"definition": "The healthcare professional responsible for authorizing the prescription.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.onBehalfOf"
},
{
"identity": "v2",
"map": "RXE-13-Ordering Provider's DEA Number / RXO-14-Ordering Provider's DEA Number / RXE-14-Pharmacist/Treatment Supplier's Verifier ID / RXO-15-Pharmacist/Treatment Supplier's Verifier ID / ORC-12-Ordering Provider / PRT-5-Participation Person: PRT-4-Participation='OP' (all but last deprecated)"
},
{
"identity": "rim",
"map": "author.role"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "VisionPrescription.reason[x]",
"path": "VisionPrescription.reason[x]",
"short": "Reason or indication for writing the prescription",
"definition": "Can be the reason or the indication for writing the prescription.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
}
],
"mapping": [
{
"identity": "v2",
"map": "ORC-16-Order Control Code Reason"
},
{
"identity": "rim",
"map": "reason.observation or reason.observation[code=ASSERTION].value"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "VisionPrescription.dispense",
"path": "VisionPrescription.dispense",
"short": "Vision supply authorization",
"definition": "Deals with details of the dispense part of the supply specification.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div",
"source": "Element"
}
],
"mapping": [
{
"identity": "rim",
"map": "component.supplyEvent"
}
]
},
{
"id": "VisionPrescription.dispense.id",
"path": "VisionPrescription.dispense.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "VisionPrescription.dispense.extension",
"path": "VisionPrescription.dispense.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "VisionPrescription.dispense.modifierExtension",
"path": "VisionPrescription.dispense.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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 that contains it. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content",
"modifiers"
],
"min": 0,
"max": "*",
"base": {
"path": "BackboneElement.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "VisionPrescription.dispense.product",
"path": "VisionPrescription.dispense.product",
"short": "Product to be supplied",
"definition": "Identifies the type of vision correction product which is required for the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "VisionProduct"
}
],
"strength": "example",
"description": "A coded concept describing the vision products.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/vision-product"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXE-2-Give Code / RXO-1-Requested Give Code / RXD-2-Dispense/Give Code"
},
{
"identity": "rim",
"map": "consumable.role"
}
]
},
{
"id": "VisionPrescription.dispense.eye",
"path": "VisionPrescription.dispense.eye",
"short": "right | left",
"definition": "The eye for which the lens applies.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "VisionEyes"
}
],
"strength": "required",
"description": "A coded concept listing the eye codes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/vision-eye-codes"
}
}
},
{
"id": "VisionPrescription.dispense.sphere",
"path": "VisionPrescription.dispense.sphere",
"short": "Lens sphere",
"definition": "Lens power measured in diopters (0.25 units).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.cylinder",
"path": "VisionPrescription.dispense.cylinder",
"short": "Lens cylinder",
"definition": "Power adjustment for astigmatism measured in diopters (0.25 units).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.axis",
"path": "VisionPrescription.dispense.axis",
"short": "Lens axis",
"definition": "Adjustment for astigmatism measured in integer degrees.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "VisionPrescription.dispense.prism",
"path": "VisionPrescription.dispense.prism",
"short": "Lens prism",
"definition": "Amount of prism to compensate for eye alignment in fractional units.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.base",
"path": "VisionPrescription.dispense.base",
"short": "up | down | in | out",
"definition": "The relative base, or reference lens edge, for the prism.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "VisionBase"
}
],
"strength": "required",
"description": "A coded concept listing the base codes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/vision-base-codes"
}
}
},
{
"id": "VisionPrescription.dispense.add",
"path": "VisionPrescription.dispense.add",
"short": "Lens add",
"definition": "Power adjustment for multifocal lenses measured in diopters (0.25 units).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.power",
"path": "VisionPrescription.dispense.power",
"short": "Contact lens power",
"definition": "Contact lens power measured in diopters (0.25 units).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.backCurve",
"path": "VisionPrescription.dispense.backCurve",
"short": "Contact lens back curvature",
"definition": "Back curvature measured in millimeters.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.diameter",
"path": "VisionPrescription.dispense.diameter",
"short": "Contact lens diameter",
"definition": "Contact lens diameter measured in millimeters.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.duration",
"path": "VisionPrescription.dispense.duration",
"short": "Lens wear duration",
"definition": "The recommended maximum wear period for the lens.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
]
},
{
"id": "VisionPrescription.dispense.color",
"path": "VisionPrescription.dispense.color",
"short": "Color required",
"definition": "Special color or pattern.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "VisionPrescription.dispense.brand",
"path": "VisionPrescription.dispense.brand",
"short": "Brand required",
"definition": "Brand recommendations or restrictions.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "VisionPrescription.dispense.note",
"path": "VisionPrescription.dispense.note",
"short": "Notes for coatings",
"definition": "Notes for special requirements such as coatings and lens materials.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
]
}
]
},
"differential": {
"element": [
{
"id": "VisionPrescription",
"path": "VisionPrescription",
"short": "Prescription for vision correction products for a patient",
"definition": "An authorization for the supply of glasses and/or contact lenses to a patient.",
"min": 0,
"max": "*",
"mapping": [
{
"identity": "workflow",
"map": "Request"
},
{
"identity": "rim",
"map": "CombinedVisionRequest"
},
{
"identity": "w5",
"map": "clinical.careprovision"
}
]
},
{
"id": "VisionPrescription.identifier",
"path": "VisionPrescription.identifier",
"short": "Business identifier",
"definition": "Business identifier which may be used by other parties to reference or identify the prescription.",
"min": 0,
"max": "*",
"type": [
{
"code": "Identifier"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.identifier"
},
{
"identity": "v2",
"map": "ORC-2-Placer Order Number / ORC-3-Filler Order Number"
},
{
"identity": "rim",
"map": "id"
},
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "VisionPrescription.status",
"path": "VisionPrescription.status",
"short": "active | cancelled | draft | entered-in-error",
"definition": "The status of the resource instance.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "VisionStatus"
}
],
"strength": "required",
"description": "A code specifying the state of the resource instance.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/fm-status"
}
},
"mapping": [
{
"identity": "workflow",
"map": "Request.status"
},
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "VisionPrescription.patient",
"path": "VisionPrescription.patient",
"short": "Who prescription is for",
"definition": "A link to a resource representing the person to whom the vision products will be supplied.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Patient"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.subject"
},
{
"identity": "v2",
"map": "PID-3-Patient ID List"
},
{
"identity": "rim",
"map": "subject.role"
},
{
"identity": "w5",
"map": "who.focus"
}
]
},
{
"id": "VisionPrescription.encounter",
"path": "VisionPrescription.encounter",
"short": "Created during encounter / admission / stay",
"definition": "A link to a resource that identifies the particular occurrence of contact between patient and health care provider.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Encounter"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.context"
},
{
"identity": "v2",
"map": "PV1-19-Visit Number"
},
{
"identity": "rim",
"map": "componentOf.patientEncounter"
},
{
"identity": "w5",
"map": "context"
}
]
},
{
"id": "VisionPrescription.dateWritten",
"path": "VisionPrescription.dateWritten",
"short": "When prescription was authorized",
"definition": "The date (and perhaps time) when the prescription was written.",
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.authoredOn"
},
{
"identity": "v2",
"map": "RXE-32-Original Order Date/Time / ORC-9-Date/Time of Transaction"
},
{
"identity": "rim",
"map": "author.time"
},
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "VisionPrescription.prescriber",
"path": "VisionPrescription.prescriber",
"short": "Who authorizes the vision product",
"definition": "The healthcare professional responsible for authorizing the prescription.",
"min": 0,
"max": "1",
"type": [
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Practitioner"
}
],
"mapping": [
{
"identity": "workflow",
"map": "Request.requester.onBehalfOf"
},
{
"identity": "v2",
"map": "RXE-13-Ordering Provider's DEA Number / RXO-14-Ordering Provider's DEA Number / RXE-14-Pharmacist/Treatment Supplier's Verifier ID / RXO-15-Pharmacist/Treatment Supplier's Verifier ID / ORC-12-Ordering Provider / PRT-5-Participation Person: PRT-4-Participation='OP' (all but last deprecated)"
},
{
"identity": "rim",
"map": "author.role"
},
{
"identity": "w5",
"map": "who.author"
}
]
},
{
"id": "VisionPrescription.reason[x]",
"path": "VisionPrescription.reason[x]",
"short": "Reason or indication for writing the prescription",
"definition": "Can be the reason or the indication for writing the prescription.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
},
{
"code": "Reference",
"targetProfile": "http://hl7.org/fhir/StructureDefinition/Condition"
}
],
"mapping": [
{
"identity": "v2",
"map": "ORC-16-Order Control Code Reason"
},
{
"identity": "rim",
"map": "reason.observation or reason.observation[code=ASSERTION].value"
},
{
"identity": "w5",
"map": "why"
}
]
},
{
"id": "VisionPrescription.dispense",
"path": "VisionPrescription.dispense",
"short": "Vision supply authorization",
"definition": "Deals with details of the dispense part of the supply specification.",
"min": 0,
"max": "*",
"type": [
{
"code": "BackboneElement"
}
],
"mapping": [
{
"identity": "rim",
"map": "component.supplyEvent"
}
]
},
{
"id": "VisionPrescription.dispense.product",
"path": "VisionPrescription.dispense.product",
"short": "Product to be supplied",
"definition": "Identifies the type of vision correction product which is required for the patient.",
"min": 0,
"max": "1",
"type": [
{
"code": "CodeableConcept"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "VisionProduct"
}
],
"strength": "example",
"description": "A coded concept describing the vision products.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/vision-product"
}
},
"mapping": [
{
"identity": "v2",
"map": "RXE-2-Give Code / RXO-1-Requested Give Code / RXD-2-Dispense/Give Code"
},
{
"identity": "rim",
"map": "consumable.role"
}
]
},
{
"id": "VisionPrescription.dispense.eye",
"path": "VisionPrescription.dispense.eye",
"short": "right | left",
"definition": "The eye for which the lens applies.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "VisionEyes"
}
],
"strength": "required",
"description": "A coded concept listing the eye codes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/vision-eye-codes"
}
}
},
{
"id": "VisionPrescription.dispense.sphere",
"path": "VisionPrescription.dispense.sphere",
"short": "Lens sphere",
"definition": "Lens power measured in diopters (0.25 units).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.cylinder",
"path": "VisionPrescription.dispense.cylinder",
"short": "Lens cylinder",
"definition": "Power adjustment for astigmatism measured in diopters (0.25 units).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.axis",
"path": "VisionPrescription.dispense.axis",
"short": "Lens axis",
"definition": "Adjustment for astigmatism measured in integer degrees.",
"min": 0,
"max": "1",
"type": [
{
"code": "integer"
}
]
},
{
"id": "VisionPrescription.dispense.prism",
"path": "VisionPrescription.dispense.prism",
"short": "Lens prism",
"definition": "Amount of prism to compensate for eye alignment in fractional units.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.base",
"path": "VisionPrescription.dispense.base",
"short": "up | down | in | out",
"definition": "The relative base, or reference lens edge, for the prism.",
"min": 0,
"max": "1",
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "VisionBase"
}
],
"strength": "required",
"description": "A coded concept listing the base codes.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/vision-base-codes"
}
}
},
{
"id": "VisionPrescription.dispense.add",
"path": "VisionPrescription.dispense.add",
"short": "Lens add",
"definition": "Power adjustment for multifocal lenses measured in diopters (0.25 units).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.power",
"path": "VisionPrescription.dispense.power",
"short": "Contact lens power",
"definition": "Contact lens power measured in diopters (0.25 units).",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.backCurve",
"path": "VisionPrescription.dispense.backCurve",
"short": "Contact lens back curvature",
"definition": "Back curvature measured in millimeters.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.diameter",
"path": "VisionPrescription.dispense.diameter",
"short": "Contact lens diameter",
"definition": "Contact lens diameter measured in millimeters.",
"min": 0,
"max": "1",
"type": [
{
"code": "decimal"
}
]
},
{
"id": "VisionPrescription.dispense.duration",
"path": "VisionPrescription.dispense.duration",
"short": "Lens wear duration",
"definition": "The recommended maximum wear period for the lens.",
"min": 0,
"max": "1",
"type": [
{
"code": "Quantity",
"profile": "http://hl7.org/fhir/StructureDefinition/SimpleQuantity"
}
]
},
{
"id": "VisionPrescription.dispense.color",
"path": "VisionPrescription.dispense.color",
"short": "Color required",
"definition": "Special color or pattern.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "VisionPrescription.dispense.brand",
"path": "VisionPrescription.dispense.brand",
"short": "Brand required",
"definition": "Brand recommendations or restrictions.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
]
},
{
"id": "VisionPrescription.dispense.note",
"path": "VisionPrescription.dispense.note",
"short": "Notes for coatings",
"definition": "Notes for special requirements such as coatings and lens materials.",
"min": 0,
"max": "*",
"type": [
{
"code": "Annotation"
}
]
}
]
}
}
},
{
"fullUrl": "http://hl7.org/fhir/StructureDefinition/MetadataResource",
"resource": {
"resourceType": "StructureDefinition",
"id": "MetadataResource",
"meta": {
"lastUpdated": "2017-04-18T21:44:43.294+00:00"
},
"text": {
"status": "generated",
"div": "Name Flags Card. Type Description & Constraints MetadataResource DomainResource Common Ancestor declaration for definitional resources
Elements defined in Ancestors: id, meta, implicitRules, language, text, contained, extension, modifierExtension url Σ 0..1 uri Logical URI to reference this metadata resource (globally unique) version Σ 0..1 string Business version of the metadata resource name Σ 0..1 string Name for this metadata resource (computer friendly) title Σ 0..1 string Name for this metadata resource (human friendly) status ?!Σ 1..1 code draft | active | retired | unknown
PublicationStatus (Required) experimental ?!Σ 0..1 boolean For testing purposes, not real usage date Σ 0..1 dateTime Date this was last changed publisher Σ 0..1 string Name of the publisher (organization or individual) contact Σ 0..* ContactDetail Contact details for the publisher
useContext Σ 0..* UsageContext Context the content is intended to support
jurisdiction Σ 0..* CodeableConcept Intended jurisdiction for metadata resource (if applicable)
Jurisdiction ValueSet (Extensible)
description 0..1 markdown Natural language description of the metadata resource
Documentation for this format
"
},
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/structuredefinition-wg",
"valueCode": "fhir"
}
],
"url": "http://hl7.org/fhir/StructureDefinition/MetadataResource",
"name": "MetadataResource",
"status": "draft",
"date": "2017-04-18T21:44:43+00:00",
"publisher": "Health Level Seven International (FHIR Infrastructure)",
"contact": [
{
"telecom": [
{
"system": "url",
"value": "http://hl7.org/fhir"
}
]
},
{
"telecom": [
{
"system": "url",
"value": "http://www.hl7.org/Special/committees/fiwg/index.cfm"
}
]
}
],
"description": "Base StructureDefinition for MetadataResource Resource",
"fhirVersion": "3.0.1",
"mapping": [
{
"identity": "w5",
"uri": "http://hl7.org/fhir/w5",
"name": "W5 Mapping"
},
{
"identity": "rim",
"uri": "http://hl7.org/v3",
"name": "RIM Mapping"
}
],
"kind": "logical",
"abstract": false,
"type": "MetadataResource",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/DomainResource",
"derivation": "specialization",
"snapshot": {
"element": [
{
"id": "MetadataResource",
"path": "MetadataResource",
"short": "Common Ancestor declaration for definitional resources",
"definition": "Common Ancestor declaration for conformance and knowledge artifact resources.",
"min": 1,
"max": "1",
"constraint": [
{
"key": "dom-2",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain nested Resources",
"expression": "contained.contained.empty()",
"xpath": "not(parent::f:contained and f:contained)",
"source": "DomainResource"
},
{
"key": "dom-1",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL NOT contain any narrative",
"expression": "contained.text.empty()",
"xpath": "not(parent::f:contained and f:text)",
"source": "DomainResource"
},
{
"key": "dom-4",
"severity": "error",
"human": "If a resource is contained in another resource, it SHALL NOT have a meta.versionId or a meta.lastUpdated",
"expression": "contained.meta.versionId.empty() and contained.meta.lastUpdated.empty()",
"xpath": "not(exists(f:contained/*/f:meta/f:versionId)) and not(exists(f:contained/*/f:meta/f:lastUpdated))",
"source": "DomainResource"
},
{
"key": "dom-3",
"severity": "error",
"human": "If the resource is contained in another resource, it SHALL be referred to from elsewhere in the resource",
"expression": "contained.where(('#'+id in %resource.descendants().reference).not()).empty()",
"xpath": "not(exists(for $id in f:contained/*/@id return $id[not(ancestor::f:contained/parent::*/descendant::f:reference/@value=concat('#', $id))]))",
"source": "DomainResource"
}
],
"mapping": [
{
"identity": "rim",
"map": "Entity. Role, or Act"
},
{
"identity": "w5",
"map": "conformance.behavior"
}
]
},
{
"id": "MetadataResource.id",
"path": "MetadataResource.id",
"short": "Logical id of this artifact",
"definition": "The logical id of the resource, as used in the URL for the resource. Once assigned, this value never changes.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "id"
}
],
"isSummary": true
},
{
"id": "MetadataResource.meta",
"path": "MetadataResource.meta",
"short": "Metadata about the resource",
"definition": "The metadata about the resource. This is content that is maintained by the infrastructure. Changes to the content may not always be associated with version changes to the resource.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.meta",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Meta"
}
],
"isSummary": true
},
{
"id": "MetadataResource.implicitRules",
"path": "MetadataResource.implicitRules",
"short": "A set of rules under which this content was created",
"definition": "A reference to a set of rules that were followed when the resource was constructed, and which must be understood when processing the content.",
"comment": "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. \n\nThis element is labelled as a modifier because the implicit rules may provide additional knowledge about the resource that modifies it's meaning or interpretation.",
"min": 0,
"max": "1",
"base": {
"path": "Resource.implicitRules",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"isModifier": true,
"isSummary": true
},
{
"id": "MetadataResource.language",
"path": "MetadataResource.language",
"short": "Language of the resource content",
"definition": "The base language in which the resource is written.",
"comment": "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": 0,
"max": "1",
"base": {
"path": "Resource.language",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-maxValueSet",
"valueReference": {
"reference": "http://hl7.org/fhir/ValueSet/all-languages"
}
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Language"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "A human language.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/languages"
}
}
},
{
"id": "MetadataResource.text",
"path": "MetadataResource.text",
"short": "Text summary of the resource, for human interpretation",
"definition": "A human-readable narrative that contains a summary of the resource, and may 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": "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 in formation is added later.",
"alias": [
"narrative",
"html",
"xhtml",
"display"
],
"min": 0,
"max": "1",
"base": {
"path": "DomainResource.text",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Narrative"
}
],
"condition": [
"dom-1"
],
"mapping": [
{
"identity": "rim",
"map": "Act.text?"
}
]
},
{
"id": "MetadataResource.contained",
"path": "MetadataResource.contained",
"short": "Contained, inline Resources",
"definition": "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": "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.",
"alias": [
"inline resources",
"anonymous resources",
"contained resources"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.contained",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Resource"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MetadataResource.extension",
"path": "MetadataResource.extension",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the resource. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MetadataResource.modifierExtension",
"path": "MetadataResource.modifierExtension",
"short": "Extensions that cannot be ignored",
"definition": "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. Usually modifier elements provide negation or qualification. In order 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.",
"comment": "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": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "DomainResource.modifierExtension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"isModifier": true,
"mapping": [
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "MetadataResource.url",
"path": "MetadataResource.url",
"short": "Logical URI to reference this metadata resource (globally unique)",
"definition": "An absolute URI that is used to identify this metadata resource when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this metadata resource is (or will be) published. The URL SHOULD include the major version of the metadata resource. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the metadata resource to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MetadataResource.version",
"path": "MetadataResource.version",
"short": "Business version of the metadata resource",
"definition": "The identifier that is used to identify this version of the metadata resource when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the metadata resource author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different metadata resource instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the metadata resource with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "MetadataResource.name",
"path": "MetadataResource.name",
"short": "Name for this metadata resource (computer friendly)",
"definition": "A natural language name identifying the metadata resource. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "MetadataResource.title",
"path": "MetadataResource.title",
"short": "Name for this metadata resource (human friendly)",
"definition": "A short, descriptive, user-friendly title for the metadata resource.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "MetadataResource.status",
"path": "MetadataResource.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this metadata resource. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of metadata resources that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired metadata resource without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MetadataResource.experimental",
"path": "MetadataResource.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this metadata resource is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of metadata resource that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental metadata resource in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level metadata resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "MetadataResource.date",
"path": "MetadataResource.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the metadata resource was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the metadata resource changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the metadata resource. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "MetadataResource.publisher",
"path": "MetadataResource.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the metadata resource.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the metadata resource is the organization or individual primarily responsible for the maintenance and upkeep of the metadata resource. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the metadata resource. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the metadata resource. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "MetadataResource.contact",
"path": "MetadataResource.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "MetadataResource.useContext",
"path": "MetadataResource.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate metadata resource instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "MetadataResource.jurisdiction",
"path": "MetadataResource.jurisdiction",
"short": "Intended jurisdiction for metadata resource (if applicable)",
"definition": "A legal or geographic region in which the metadata resource is intended to be used.",
"comment": "It may be possible for the metadata resource to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "MetadataResource.description",
"path": "MetadataResource.description",
"short": "Natural language description of the metadata resource",
"definition": "A free text natural language description of the metadata resource from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the metadata resource was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the metadata resource as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
}
]
},
"differential": {
"element": [
{
"id": "MetadataResource",
"path": "MetadataResource",
"short": "Common Ancestor declaration for definitional resources",
"definition": "Common Ancestor declaration for conformance and knowledge artifact resources.",
"min": 1,
"max": "1",
"mapping": [
{
"identity": "w5",
"map": "conformance.behavior"
}
]
},
{
"id": "MetadataResource.url",
"path": "MetadataResource.url",
"short": "Logical URI to reference this metadata resource (globally unique)",
"definition": "An absolute URI that is used to identify this metadata resource when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this metadata resource is (or will be) published. The URL SHOULD include the major version of the metadata resource. For more information see [Technical and Business Versions](resource.html#versions).",
"comment": "Can be a urn:uuid: or a urn:oid:, but real http: addresses are preferred. Multiple instances may share the same url if they have a distinct version.",
"requirements": "Allows the metadata resource to be referenced by a single globally unique identifier.",
"min": 0,
"max": "1",
"type": [
{
"code": "uri"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id"
}
]
},
{
"id": "MetadataResource.version",
"path": "MetadataResource.version",
"short": "Business version of the metadata resource",
"definition": "The identifier that is used to identify this version of the metadata resource when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the metadata resource author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
"comment": "There may be different metadata resource instances that have the same identifier but different versions. The version can be appended to the url in a reference to allow a refrence to a particular business version of the metadata resource with the format [url]|[version].",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "id.version"
}
]
},
{
"id": "MetadataResource.name",
"path": "MetadataResource.name",
"short": "Name for this metadata resource (computer friendly)",
"definition": "A natural language name identifying the metadata resource. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
"comment": "The name is not expected to be globally unique. The name should be a simple alpha-numeric type name to ensure that it is computable friendly.",
"requirements": "Support human navigation and code generation.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "MetadataResource.title",
"path": "MetadataResource.title",
"short": "Name for this metadata resource (human friendly)",
"definition": "A short, descriptive, user-friendly title for the metadata resource.",
"comment": "This name does not need to be machine-processing friendly and may contain punctuation, white-space, etc.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true
},
{
"id": "MetadataResource.status",
"path": "MetadataResource.status",
"short": "draft | active | retired | unknown",
"definition": "The status of this metadata resource. Enables tracking the life-cycle of the content.",
"comment": "Allows filtering of metadata resources that are appropriate for use vs. not. \nThis is labeled as \"Is Modifier\" because applications should not use a retired metadata resource without due consideration.",
"min": 1,
"max": "1",
"type": [
{
"code": "code"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "PublicationStatus"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "required",
"description": "The lifecycle status of a Value Set or Concept Map.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/publication-status"
}
},
"mapping": [
{
"identity": "w5",
"map": "status"
}
]
},
{
"id": "MetadataResource.experimental",
"path": "MetadataResource.experimental",
"short": "For testing purposes, not real usage",
"definition": "A boolean value to indicate that this metadata resource is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.",
"comment": "Allows filtering of metadata resource that are appropriate for use vs. not. This is labeled as \"Is Modifier\" because applications should not use an experimental metadata resource in production.",
"requirements": "Enables experimental content to be developed following the same lifecycle that would be used for a production-level metadata resource.",
"min": 0,
"max": "1",
"type": [
{
"code": "boolean"
}
],
"isModifier": true,
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "class"
}
]
},
{
"id": "MetadataResource.date",
"path": "MetadataResource.date",
"short": "Date this was last changed",
"definition": "The date (and optionally time) when the metadata resource was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the metadata resource changes.",
"comment": "Note that this is not the same as the resource last-modified-date, since the resource may be a secondary representation of the metadata resource. Additional specific dates may be added as extensions or be found by consulting Provenances associated with past versions of the resource.",
"alias": [
"Revision Date"
],
"min": 0,
"max": "1",
"type": [
{
"code": "dateTime"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "when.recorded"
}
]
},
{
"id": "MetadataResource.publisher",
"path": "MetadataResource.publisher",
"short": "Name of the publisher (organization or individual)",
"definition": "The name of the individual or organization that published the metadata resource.",
"comment": "Usually an organization, but may be an individual. The publisher (or steward) of the metadata resource is the organization or individual primarily responsible for the maintenance and upkeep of the metadata resource. This is not necessarily the same individual or organization that developed and initially authored the content. The publisher is the primary point of contact for questions or issues with the metadata resource. This item SHOULD be populated unless the information is available from context.",
"requirements": "Helps establish the \"authority/credibility\" of the metadata resource. May also allow for contact.",
"min": 0,
"max": "1",
"type": [
{
"code": "string"
}
],
"isSummary": true,
"mapping": [
{
"identity": "w5",
"map": "who.witness"
}
]
},
{
"id": "MetadataResource.contact",
"path": "MetadataResource.contact",
"short": "Contact details for the publisher",
"definition": "Contact details to assist a user in finding and communicating with the publisher.",
"comment": "May be a web site, an email address, a telephone number, etc.",
"min": 0,
"max": "*",
"type": [
{
"code": "ContactDetail"
}
],
"isSummary": true
},
{
"id": "MetadataResource.useContext",
"path": "MetadataResource.useContext",
"short": "Context the content is intended to support",
"definition": "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate metadata resource instances.",
"comment": "When multiple useContexts are specified, there is no expectation whether all or any of the contexts apply.",
"requirements": "Assist in searching for appropriate content.",
"min": 0,
"max": "*",
"type": [
{
"code": "UsageContext"
}
],
"isSummary": true
},
{
"id": "MetadataResource.jurisdiction",
"path": "MetadataResource.jurisdiction",
"short": "Intended jurisdiction for metadata resource (if applicable)",
"definition": "A legal or geographic region in which the metadata resource is intended to be used.",
"comment": "It may be possible for the metadata resource to be used in jurisdictions other than those for which it was originally designed or intended.",
"min": 0,
"max": "*",
"type": [
{
"code": "CodeableConcept"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "Jurisdiction"
},
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-isCommonBinding",
"valueBoolean": true
}
],
"strength": "extensible",
"description": "Countries and regions within which this artifact is targeted for use",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/jurisdiction"
}
}
},
{
"id": "MetadataResource.description",
"path": "MetadataResource.description",
"short": "Natural language description of the metadata resource",
"definition": "A free text natural language description of the metadata resource from a consumer's perspective.",
"comment": "This description can be used to capture details such as why the metadata resource was built, comments about misuse, instructions for clinical use and interpretation, literature references, examples from the paper world, etc. It is not a rendering of the metadata resource as conveyed in the 'text' field of the resource itself. This item SHOULD be populated unless the information is available from context (e.g. the language of the profile is presumed to be the predominant language in the place the profile was created).",
"min": 0,
"max": "1",
"type": [
{
"code": "markdown"
}
]
}
]
}
}
}
]
}