Foundation
This
page
is
part
of
the
FHIR
Specification
(v3.0.2:
(v4.0.1:
R4
-
Mixed
Normative
and
STU
3).
)
in
it's
permanent
home
(it
will
always
be
available
at
this
URL).
The
current
version
which
supercedes
this
version
is
5.0.0
.
For
a
full
list
of
available
versions,
see
the
Directory
of
published
versions
.
Page
versions:
R5
R4B
R4
R3
R4
R3
R2
|
FHIR
Infrastructure
Work
Group
|
Maturity
Level
:
|
|
|
This
page
has
been
approved
as
part
of
an
ANSI
standard.
See
the
Infrastructure
Package
for
further
details.
|
This exchange specification is based on generally agreed common requirements across healthcare - covering many jurisdictions, domains, and different functional approaches. It is common for specific implementations to have valid requirements that are not part of these agreed common requirements. Incorporating all valid requirements would make this specification very cumbersome and difficult to implement. Instead, this specification expects that additional valid requirements will be implemented as extensions.
As such, extensibility is a fundamental part of the design of this specification. Every element in a resource can have extension child elements to represent additional information that is not part of the basic definition of the resource. Applications should not reject resources merely because they contain extensions, though they may need to reject resources because of the specific contents of the extensions.
Note that, unlike in many other specifications, there can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core simplicity for everyone.
To make the use of extensions safe and manageable, there is strict governance applied to the definition and use of extensions. Although any implementer can define and use extensions, there is a set of requirements that must be met as part of their use and definition.
Every
element
in
a
resource
or
data
type
includes
an
optional
"extension"
"extension"
child
element
that
may
be
present
any
number
of
times.
This
is
the
content
model
of
the
extension
as
it
appears
in
each
resource:
Structure
| Name | Flags | Card. | Type |
Description
&
Constraints
|
|---|---|---|---|---|
Extension
|
I N | Element |
Optional
Extensions
Element
+ Rule: Must have either extensions or value[x], not both Elements defined in Ancestors: id , extension |
|
url
|
1..1 | uri | identifies the meaning of the extension | |
value[x]
|
0..1 | * | Value of extension | |
|
Documentation
for
this
format
|
||||
UML Diagram ( Legend )
XML Template
<<extension|modifierExtension xmlns="http://hl7.org/fhir" url="identifies the meaning of the extension (uri)"> <!-- from Element: extension --><</value[x]><value[x]><!-- 0..1 * Value of extension --></value[x]> </extension|modifierExtension>
JSON Template
{
// from Element: extension
"
">
">
">"
">"
">"
">"
">"
">
">"
">"
" }
" }
" }
" }
" }
" }
" }
" }
" }
" }
" }
" }
" }
"url" : "<uri>", // R! identifies the meaning of the extension
// value[x]: Value of extension. One of these 50:
"valueBase64Binary" : "<base64Binary>"
"valueBoolean" : <boolean>
"valueCanonical" : "<canonical>"
"valueCode" : "<code>"
"valueDate" : "<date>"
"valueDateTime" : "<dateTime>"
"valueDecimal" : <decimal>
"valueId" : "<id>"
"valueInstant" : "<instant>"
"valueInteger" : <integer>
"valueMarkdown" : "<markdown>"
"valueOid" : "<oid>"
"valuePositiveInt" : "<positiveInt>"
"valueString" : "<string>"
"valueTime" : "<time>"
"valueUnsignedInt" : "<unsignedInt>"
"valueUri" : "<uri>"
"valueUrl" : "<url>"
"valueUuid" : "<uuid>"
"valueAddress" : { Address }
"valueAge" : { Age }
"valueAnnotation" : { Annotation }
"valueAttachment" : { Attachment }
"valueCodeableConcept" : { CodeableConcept }
"valueCoding" : { Coding }
"valueContactPoint" : { ContactPoint }
"valueCount" : { Count }
"valueDistance" : { Distance }
"valueDuration" : { Duration }
"valueHumanName" : { HumanName }
"valueIdentifier" : { Identifier }
"valueMoney" : { Money }
"valuePeriod" : { Period }
"valueQuantity" : { Quantity }
"valueRange" : { Range }
"valueRatio" : { Ratio }
"valueReference" : { Reference }
"valueSampledData" : { SampledData }
"valueSignature" : { Signature }
"valueTiming" : { Timing }
"valueContactDetail" : { ContactDetail }
"valueContributor" : { Contributor }
"valueDataRequirement" : { DataRequirement }
"valueExpression" : { Expression }
"valueParameterDefinition" : { ParameterDefinition }
"valueRelatedArtifact" : { RelatedArtifact }
"valueTriggerDefinition" : { TriggerDefinition }
"valueUsageContext" : { UsageContext }
"valueDosage" : { Dosage }
"valueMeta" : { Meta }
}
Turtle Template
@prefix fhir: <http://hl7.org/fhir/> . [ # from Element: Element.extension fhir:Extension.url [ uri ]; # 1..1 identifies the meaning of the extension# . One of these 38 fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ]# Extension.value[x] : 0..1 Value of extension. One of these 50 fhir:Extension.valueBase64Binary [ base64Binary ] fhir:Extension.valueBoolean [ boolean ] fhir:Extension.valueCanonical [ canonical ] fhir:Extension.valueCode [ code ] fhir:Extension.valueDate [ date ] fhir:Extension.valueDateTime [ dateTime ] fhir:Extension.valueDecimal [ decimal ] fhir:Extension.valueId [ id ] fhir:Extension.valueInstant [ instant ] fhir:Extension.valueInteger [ integer ] fhir:Extension.valueMarkdown [ markdown ] fhir:Extension.valueOid [ oid ] fhir:Extension.valuePositiveInt [ positiveInt ] fhir:Extension.valueString [ string ] fhir:Extension.valueTime [ time ] fhir:Extension.valueUnsignedInt [ unsignedInt ] fhir:Extension.valueUri [ uri ] fhir:Extension.valueUrl [ url ] fhir:Extension.valueUuid [ uuid ] fhir:Extension.valueAddress [ Address ] fhir:Extension.valueAge [ Age ] fhir:Extension.valueAnnotation [ Annotation ] fhir:Extension.valueAttachment [ Attachment ] fhir:Extension.valueCodeableConcept [ CodeableConcept ] fhir:Extension.valueCoding [ Coding ] fhir:Extension.valueContactPoint [ ContactPoint ] fhir:Extension.valueCount [ Count ] fhir:Extension.valueDistance [ Distance ] fhir:Extension.valueDuration [ Duration ] fhir:Extension.valueHumanName [ HumanName ] fhir:Extension.valueIdentifier [ Identifier ] fhir:Extension.valueMoney [ Money ] fhir:Extension.valuePeriod [ Period ] fhir:Extension.valueQuantity [ Quantity ] fhir:Extension.valueRange [ Range ] fhir:Extension.valueRatio [ Ratio ] fhir:Extension.valueReference [ Reference ] fhir:Extension.valueSampledData [ SampledData ] fhir:Extension.valueSignature [ Signature ] fhir:Extension.valueTiming [ Timing ] fhir:Extension.valueContactDetail [ ContactDetail ] fhir:Extension.valueContributor [ Contributor ] fhir:Extension.valueDataRequirement [ DataRequirement ] fhir:Extension.valueExpression [ Expression ] fhir:Extension.valueParameterDefinition [ ParameterDefinition ] fhir:Extension.valueRelatedArtifact [ RelatedArtifact ] fhir:Extension.valueTriggerDefinition [ TriggerDefinition ] fhir:Extension.valueUsageContext [ UsageContext ] fhir:Extension.valueDosage [ Dosage ] fhir:Extension.valueMeta [ Meta ] ]
Changes
since
DSTU2
Release
3
| Extension | |
| Extension.value[x] |
|
See the Full Difference for further information
Structure
| Name | Flags | Card. | Type |
Description
&
Constraints
|
|---|---|---|---|---|
|
Extension
|
I N | Element |
Optional
Extensions
Element
+ Rule: Must have either extensions or value[x], not both Elements defined in Ancestors: id , extension |
|
|
url
|
1..1 | uri | identifies the meaning of the extension | |
|
value[x]
|
0..1 | * | Value of extension | |
|
Documentation
for
this
format
|
||||
XML Template
<<extension|modifierExtension xmlns="http://hl7.org/fhir" url="identifies the meaning of the extension (uri)"> <!-- from Element: extension --><</value[x]><value[x]><!-- 0..1 * Value of extension --></value[x]> </extension|modifierExtension>
JSON Template
{
// from Element: extension
"
">
">
">"
">"
">"
">"
">"
">
">"
">"
" }
" }
" }
" }
" }
" }
" }
" }
" }
" }
" }
" }
" }
"url" : "<uri>", // R! identifies the meaning of the extension
// value[x]: Value of extension. One of these 50:
"valueBase64Binary" : "<base64Binary>"
"valueBoolean" : <boolean>
"valueCanonical" : "<canonical>"
"valueCode" : "<code>"
"valueDate" : "<date>"
"valueDateTime" : "<dateTime>"
"valueDecimal" : <decimal>
"valueId" : "<id>"
"valueInstant" : "<instant>"
"valueInteger" : <integer>
"valueMarkdown" : "<markdown>"
"valueOid" : "<oid>"
"valuePositiveInt" : "<positiveInt>"
"valueString" : "<string>"
"valueTime" : "<time>"
"valueUnsignedInt" : "<unsignedInt>"
"valueUri" : "<uri>"
"valueUrl" : "<url>"
"valueUuid" : "<uuid>"
"valueAddress" : { Address }
"valueAge" : { Age }
"valueAnnotation" : { Annotation }
"valueAttachment" : { Attachment }
"valueCodeableConcept" : { CodeableConcept }
"valueCoding" : { Coding }
"valueContactPoint" : { ContactPoint }
"valueCount" : { Count }
"valueDistance" : { Distance }
"valueDuration" : { Duration }
"valueHumanName" : { HumanName }
"valueIdentifier" : { Identifier }
"valueMoney" : { Money }
"valuePeriod" : { Period }
"valueQuantity" : { Quantity }
"valueRange" : { Range }
"valueRatio" : { Ratio }
"valueReference" : { Reference }
"valueSampledData" : { SampledData }
"valueSignature" : { Signature }
"valueTiming" : { Timing }
"valueContactDetail" : { ContactDetail }
"valueContributor" : { Contributor }
"valueDataRequirement" : { DataRequirement }
"valueExpression" : { Expression }
"valueParameterDefinition" : { ParameterDefinition }
"valueRelatedArtifact" : { RelatedArtifact }
"valueTriggerDefinition" : { TriggerDefinition }
"valueUsageContext" : { UsageContext }
"valueDosage" : { Dosage }
"valueMeta" : { Meta }
}
Turtle Template
@prefix fhir: <http://hl7.org/fhir/> . [ # from Element: Element.extension fhir:Extension.url [ uri ]; # 1..1 identifies the meaning of the extension# . One of these 38 fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ] fhir: ]# Extension.value[x] : 0..1 Value of extension. One of these 50 fhir:Extension.valueBase64Binary [ base64Binary ] fhir:Extension.valueBoolean [ boolean ] fhir:Extension.valueCanonical [ canonical ] fhir:Extension.valueCode [ code ] fhir:Extension.valueDate [ date ] fhir:Extension.valueDateTime [ dateTime ] fhir:Extension.valueDecimal [ decimal ] fhir:Extension.valueId [ id ] fhir:Extension.valueInstant [ instant ] fhir:Extension.valueInteger [ integer ] fhir:Extension.valueMarkdown [ markdown ] fhir:Extension.valueOid [ oid ] fhir:Extension.valuePositiveInt [ positiveInt ] fhir:Extension.valueString [ string ] fhir:Extension.valueTime [ time ] fhir:Extension.valueUnsignedInt [ unsignedInt ] fhir:Extension.valueUri [ uri ] fhir:Extension.valueUrl [ url ] fhir:Extension.valueUuid [ uuid ] fhir:Extension.valueAddress [ Address ] fhir:Extension.valueAge [ Age ] fhir:Extension.valueAnnotation [ Annotation ] fhir:Extension.valueAttachment [ Attachment ] fhir:Extension.valueCodeableConcept [ CodeableConcept ] fhir:Extension.valueCoding [ Coding ] fhir:Extension.valueContactPoint [ ContactPoint ] fhir:Extension.valueCount [ Count ] fhir:Extension.valueDistance [ Distance ] fhir:Extension.valueDuration [ Duration ] fhir:Extension.valueHumanName [ HumanName ] fhir:Extension.valueIdentifier [ Identifier ] fhir:Extension.valueMoney [ Money ] fhir:Extension.valuePeriod [ Period ] fhir:Extension.valueQuantity [ Quantity ] fhir:Extension.valueRange [ Range ] fhir:Extension.valueRatio [ Ratio ] fhir:Extension.valueReference [ Reference ] fhir:Extension.valueSampledData [ SampledData ] fhir:Extension.valueSignature [ Signature ] fhir:Extension.valueTiming [ Timing ] fhir:Extension.valueContactDetail [ ContactDetail ] fhir:Extension.valueContributor [ Contributor ] fhir:Extension.valueDataRequirement [ DataRequirement ] fhir:Extension.valueExpression [ Expression ] fhir:Extension.valueParameterDefinition [ ParameterDefinition ] fhir:Extension.valueRelatedArtifact [ RelatedArtifact ] fhir:Extension.valueTriggerDefinition [ TriggerDefinition ] fhir:Extension.valueUsageContext [ UsageContext ] fhir:Extension.valueDosage [ Dosage ] fhir:Extension.valueMeta [ Meta ] ]
Changes
since
DSTU2
Release
3
| Extension | |
| Extension.value[x] |
|
See the Full Difference for further information
Notes:
url
is
a
mandatory
attribute
/
property
and
identifies
a
retrievable
extension
definition
that
defines
the
content
and
meaning
of
the
extension
url
SHALL
be
a
URL,
not
a
URN
(e.g.
not
an
OID
or
a
UUID),
and
it
SHALL
be
the
canonical
URL
of
a
StructureDefinition
that
defines
the
extension.
Except
for
child
extensions
defined
within
complex
extensions,
the
URL
SHALL
be
an
absolute
URL.
extension
element
Here
is
an
example
of
an
extension
in
XML:
XML
(
see
definition
):
<name><extension url="http://hl7.org/fhir/StructureDefinition/iso-21090-name-use" > <valueCode value="I" /><extension url="http://hl7.org/fhir/StructureDefinition/iso-21090-EN-use" > <valueCode value="I" /> </extension><text value="Chief Red Cloud"/><text value="Chief Red Cloud"/> </name>
In
this
example
the
name
with
text
=
"Chief
"Chief
Red
Cloud"
Cloud"
is
extended
to
have
a
name
use
code
of
"Indigenous"
"Indigenous"
(defined
in
ISO
21090,
but
very
rarely
used
in
practice).
In JSON, extensions are represented similarly:
{
"extension" : [{
"url" : "http://hl7.org/fhir/StructureDefinition/iso-21090-name-use",
"valueCode" : "I"
"extension" : [{
"url" : "http://hl7.org/fhir/StructureDefinition/iso-21090-EN-use",
"valueCode" : "I"
}],
"text" : "Chief Red Cloud"
"text" : "Chief Red Cloud"
}
Making the types explicit in the representation means that all systems can read and write (and therefore store and/or exchange) extensions correctly without needing to access the definition of the extension.
Note that the JSON representation for extensions on primitive data types is handled differently. See Representing primitive types in JSON for further information.
Extensions can also contain extensions, either because the extension definition itself defines complex content - that is, a nested tree of values in the extension - or because the extension is extended with an additional extension defined separately.
In the case where an extension defines complex content, the identity of the parts of the extension are local/relative to the reference to the extension definition.
As
an
example,
consider
extending
a
patient
with
an
opt-in
status
for
a
clinical
trial
information
about
citizenship
(
see
definition
)
containing
3
2
fields:
clinical
trial
number,
period
of
involvement,
code
and
a
reason
for
enrollment.
period.
In
XML:
<Patient><extension url="http://hl7.org/fhir/StructureDefinition/patient-clinicalTrial" > <extension url="NCT" > <valueString value="123456789" /> </extension> <extension url="period" > <valuePeriod> <start value="2009-03-14" /> </valuePeriod> </extension> <extension url="reason" ><extension url="http://hl7.org/fhir/StructureDefinition/patient-citizenship" > <extension url="code" > <valueCodeableConcept> <coding><system value="http://acme.org/codes/general" /> <code value="tt14j" /><system value="urn:iso:std:iso:3166" /> <code value="DE" /> </coding> </valueCodeableConcept> </extension> <extension url="period" > <valuePeriod> <start value="2009-03-14" /> </valuePeriod> </extension> </extension> <!-- other data for patient --> </Patient>
Or in JSON:
{
"resourceType" : "Patient",
"extension" : [{
"url" : "http://hl7.org/fhir/StructureDefinition/patient-clinicalTrial",
"extension" : [{
"url" : "NCT",
"valueString" : "123456789"
}, {
"url" : "period",
"valuePeriod" : {
"start" : "2009-03-14"
}
}, {
"url" : "reason",
"valueCodeableConcept" : {
"coding" : [{
"system" : "http://acme.org/codes/general",
"code" : "tt14j"
"resourceType" : "Patient",
"extension" : [{
"url" : "http://hl7.org/fhir/StructureDefinition/patient-citizenship",
"extension" : [{
"url" : "code",
"valueCodeableConcept" : {
"coding" : [{
"system" : "urn:iso:std:iso:3166",
"code" : "DE"
}]
}
}, {
"url" : "period",
"valuePeriod" : {
"start" : "2009-03-14"
}
}]
}]
}]
}
As
the
URL
suggests,
this
extension
is
defined
as
part
of
this
specification
.
This
extension
can
be
extended
again,
by
adding
a
"registrar"
"passport-number"
extension:
The
registrar
passport
number
is
defined
as
a
separate
extension
(e.g.
by
an
implementing
organization)
organization,
not
in
this
specification)
rather
than
part
of
the
official
clinical-trial
citizenship
extension.
The
URL
of
the
extension
is
thus
different.
In
XML:
<Patient><extension url="http://hl7.org/fhir/StructureDefinition/patient-clinicalTrial" > <extension url="NCT" > <valueString value="123456789" /> </extension> <extension url="period" > <valuePeriod> <start value="2009-03-14" /> </valuePeriod> </extension> <extension url="reason" ><extension url="http://hl7.org/fhir/StructureDefinition/patient-citizenship" > <extension url="code" > <valueCodeableConcept> <coding><system value="http://acme.org/codes/general" /> <code value="tt14j" /><system value="urn:iso:std:iso:3166" /> <code value="DE" /> </coding> </valueCodeableConcept> </extension></extension> <extension url="http://acme.org/fhir/StructureDefinition/registrar" > <valueReference> <reference value="Practitioner/example" /> </valueReference><extension url="period" > <valuePeriod> <start value="2009-03-14" /> </valuePeriod> </extension><!-- other data for patient --><extension url="http://acme.org/fhir/StructureDefinition/passport-number" > <valueString value="12345ABC" /> </extension> <!-- other data for patient --> </extension> </Patient>
or in JSON:
{
"resourceType": "Patient",
"extension": [{
"url": "http://hl7.org/fhir/StructureDefinition/patient-clinicalTrial",
"extension": [{
"url": "NCT",
"valueString": "123456789"
},
{
"url": "period",
"valuePeriod": {
"start": "2009-03-14"
}
},
{
"url": "reason",
"valueCodeableConcept": {
"coding": [{
"system": "http://acme.org/codes/general",
"code": "tt14j"
}]
}
},
"resourceType" : "Patient",
"extension" : [{
"url" : "http://hl7.org/fhir/StructureDefinition/patient-citizenship",
"extension" : [{
"url" : "code",
"valueCodeableConcept" : {
"coding" : [{
"system" : "urn:iso:std:iso:3166",
"code" : "DE"
}]
}
},{
"url" : "period",
"valuePeriod" : {
"start" : "2009-03-14"
}
},
{
"url": "http://acme.org/fhir/StructureDefinition/registrar",
"valueReference": {
"reference": "Practitioner/example"
}
}]
}]
"url": "http://acme.org/fhir/StructureDefinition/passport-number",
"valueString": "12345ABC"
}]
}]
}
Note that this passport number extension is shown here as an example defined by a fake organization, and not appropriate for re-use by implementers.
There are some cases where the information provided in an extension modifies the meaning of the element that contains it. Typically, this means information that qualifies or negates the primary meaning of the element that contains it. Some examples:
Such
extensions
are
known
as
"modifier
extensions".
"modifier
extensions".
For
further
information,
see
the
definition
of
what
makes
an
element
-
or
an
extension
-
a
modifier
.
If
modifier
extensions
are
present,
an
application
is
restricted
in
its
ability
to
safely
process
the
resource
unless
it
knows
what
the
extension
means
for
its
own
use
of
the
data.
Implementers
should
SHOULD
avoid
the
use
of
modifier
extensions
where
possible.
Any
use
should
be
carefully
considered
against
its
possible
downstream
consequences.
Inclusion
of
modifier
extensions
in
an
instance
would
be
expected
to
significantly
limit
the
ability
of
other
systems
to
process
the
instance.
However,
implementers
are
often
forced
into
these
situations
by
the
business
arrangements
around
the
use
of
resources,
so
this
specification
creates
a
framework
for
handling
such
cases.
If
modifier
extensions
Implementers
who
are
present,
introducing
an
application
cannot
safely
process
the
resource
unless
it
knows
what
extension
and
are
uncertain
whether
the
extension
means
for
its
own
use
of
should
be
marked
as
a
modifier
are
encouraged
to
raise
the
data.
question
on
chat.fhir.org
.
This
specification
allows
for
such
modifier
elements
to
be
included
at
the
base
of
a
resource
or
in
any
elements
that
do
not
have
a
data
type
(e.g.
the
elements
that
correspond
to
classes
in
the
resource
UML
diagrams).
Elements
that
are
diagrams),
and
on
a
few
specially
selected
data
types,
or
that
are
types
.
Other
data
types
and
elements
inside
data
types
SHALL
NOT
have
modifier
extensions,
and
extensions
SHALL
NOT
have
modifier
extensions
internally.
internally
(except
for
the
reusable
structures
allowed
to
appear
in
extensions,
listed
above).
Note
that
complex
extensions
are
allowed
to
have
elements
in
the
complex
extension
that
are
marked
Is-Modifier
=
true
,
which
means
that
these
elements
modify
the
extension
value
itself.
Extensions
Internal
extensions
like
this
marked
"Is-Modifier"
"Is-Modifier"
are
still
represented
using
the
extension
element
,
element,
not
modifierExtension
because
the
impact
of
the
modifier
element
is
expected
to
be
known
by
applications
that
understand
the
containing
extension.
Any
Modifier
extensions
SHALL
NOT
change
the
meaning
of
any
elements
on
Resource
or
DomainResource
(including
cannot
change
the
meaning
of
modifierExtension
itself).
Is-modifier
elements
not
defined
outside
as
part
of
an
extension
extension's
definition
cannot
be
placed
in
another
extension.
STU
Note:
Is
this
a
problem?
Input
from
implementers
identifying
places
where
modifier
extensions
might
be
needed
inside
other
extensions
is
welcome
here
.
conveyed.
In
XML,
these
modifier
elements
are
represented
using
an
element
named
modifierExtension
,
which
has
same
content
as
the
extension
element
documented
above:
Example:
There's
no
element
on
MedicationRequest
to
write
an
"anti-prescription"
"anti-prescription"
-
an
instruction
not
to
take
a
medication
for
a
particular
period.
Classical
clinical
recording
systems
do
not
record
this
as
a
prescription
-
but
one
particular
system
does,
and
these
"anti-prescription"
"anti-prescription"
records
need
to
be
shared
within
the
institution
where
this
happens
as
they
are
an
important
part
of
the
workflow.
Hence,
applications
are
allowed
to
extend
a
resource
with
data
like
this:
<MedicationRequest><modifierExtension url="http://example.org/fhir/StructureDefinition/anti-prescription"> <valueBoolean value="true"/><modifierExtension url="http://example.org/fhir/StructureDefinition/anti-prescription"> <valueBoolean value="true"/> </modifierExtension> <!-- ... other content ... --> </MedicationRequest>
Or in JSON:
{
"resourceType" : "MedicationRequest",
"modifierExtension" : [{
"url" : "http://example.org/fhir/StructureDefinition/anti-prescription",
"valueBoolean" : "true"
"resourceType" : "MedicationRequest",
"modifierExtension" : [{
"url" : "http://example.org/fhir/StructureDefinition/anti-prescription",
"valueBoolean" : true
}],
.. other content ...
}
Implementations
processing
the
data
in
resources
SHALL
check
for
modifiers
anywhere
they
could
appear,
and
if
a
modifier
extension
is
present,
present
on
a
data
element
that
the
application
'processes',
SHALL
do
one
of
these
things:
extensions
or
generated
,
display
the
narrative
and
don't
process
the
discrete
data
Processing
the
data
of
a
resource
typically
means
copying
or
filtering
data
out
of
a
resource
for
use
in
another
context
(display
to
a
human,
decision
support,
exchange
in
another
format
where
not
all
information
is
included,
or
storing
it
for
this
kind
of
use).
Servers
and
background
processes
that
simply
move
whole
resources
around
unchanged
are
not
"processing
"processing
the
data
of
the
resource",
resource",
and
therefore
these
applications
are
not
required
to
check
for
unknown
modifier
extensions.
#1
:
When
an
application
understands
this
extension,
it
means
that
some
developer
has
provided
appropriate
instructions
for
what
to
do
with
the
data
contained
in
it
because
of
the
existence
of
the
modifier
extension.
extension
or
has
determined
that
the
modifier
does
not
impact
on
the
system's
computational
functions.
Note
that
this
assessment
needs
to
be
repeated
each
time
a
system's
computational
behavior
changes
#2
:
This
means
that
implementations
are
not
inherently
required
to
"support"
"support"
a
modifier
extension
in
any
meaningful
way
-
they
can
achieve
this
understanding
by
rejecting
instances
that
contain
this
extension
(a
server,
for
instance,
could
return
a
HTTP
422
status
code
with
an
OperationOutcome
if
a
client
PUTs
or
POSTs
a
modifier
extension
it
does
not
know).
Applications
might
also
be
able
to
ignore
a
modifier
extension
if
they
know
that
it
is
safe
to
do
so
in
their
own
context,
though
this
would
not
usually
be
the
case.
Implementations SHALL ensure that they do not process data containing unrecognized modifier extensions. Note that implementations might be able to be sure, due to their implementation environment (e.g. specific trading partner agreement), that modifier extensions will never occur, and can therefore meet the requirement to check for modifiers at the design stage. However, since integration and deployment options often change, applications SHOULD always check for modifier extensions when processing resources.
#3 : One way to warn the user is to download the extension definition from the given URL, and then use the defined display name to present the extension to the user. An error message could look something like this:
Note that the narrative of the resource SHALL contain modifying information, so it is safe to show this to the user as an expression of the resource's content. A warning dialog box could be extended to offer the user the choice to see the original narrative.
Here is the prescription example from above with narrative:
<MedicationRequest xmlns="http://hl7.org/fhir"><MedicationRequest xmlns="http://hl7.org/fhir"> <text><status value="generated"/> <div xmlns="http://www.w3.org/1999/xhtml"><status value="generated"/> <div xmlns="http://www.w3.org/1999/xhtml"> <p><b>Note: This prescription is an instruction NOT to take a medication</b></p> <!-- snip actual narrative --> </div> </text> <!-- ...data... --><modifierExtension url="http://example.org/fhir/StructureDefinition/anti-prescription"> <valueBoolean value="true"/><modifierExtension url="http://example.org/fhir/StructureDefinition/anti-prescription"> <valueBoolean value="true"/> </modifierExtension> <!-- ...data... --> </MedicationRequest>
An
application
only
needs
to
concern
itself
with
modifier
extensions
on
elements
that
it
processes.
Take,
for
example,
a
case
where
a
procedure
resource
has
a
modifier
extension
on
one
of
the
performer
elements
indicating
that
they
did
not
participate
in
the
procedure.
If
an
application
is
not
using
the
performer
details
at
all,
the
fact
that
one
of
the
performers
has
a
modifier
extension
is
irrelevant
and
the
application
is
free
to
ignore
it.
If
the
application
does
process
the
performers,
and
it
sees
the
modifier
extension,
it
must
act
in
one
of
the
ways
outlined
above.
Implementation Guides might place limitations on the appearance of modifier extensions within instances that comply with the implementation guide.
In some cases, implementers might find that they do not have appropriate data for an element with minimum cardinality = 1. In this case, the element must be present, but unless the resource or a profile on it has made the actual value of the primitive data type mandatory, it is possible to provide an extension that explains why the primitive value is not present:
<uri><extension url="http://hl7.org/fhir/StructureDefinition/data-absent-reason"> <valueCode="unknown"/><extension url="http://hl7.org/fhir/StructureDefinition/data-absent-reason"> <valueCode="unknown"/> </extension> </uri>
In this example, instead of a value, a data missing code is provided. Note that it is not required that this particular extension be used. This extension is not a modifier extension, because the primitive data type has no value.
It
is
not
valid
to
create
a
fictional
piece
of
data
for
the
primitive
value,
and
then
add
an
extension
indicating
that
the
data
has
been
constructed
to
meet
the
data
rules.
This
would
be
both
a
bad
idea,
and
idea
as
well
as
a
modifier
extension,
which
is
not
allowed
on
simple
data
types.
Note: This section describes the use of "non-modifier extensions", except where "modifier extensions" are explicitly mentioned (see Modifier Extensions above for details).
Extensions are a way of allowing local requirements to be reflected in a resource using a common information based approach so that all systems can confidently process them using the same tools. However, when it comes to processing the information, applications will be constrained in their ability to handle extensions by the degree to which they are informed about them.
While the structured definition of an extension should always be available (see below for details), the mere availability of a definition does not automatically mean that applications know how to handle them correctly - generally, human decisions are required to determine how the data in extensions should be handled, along with the implicit obligations that surround the information.
For
this
reason,
local
requirements
that
manifest
as
extensions
are
an
obstacle
to
integration
and
interoperability.
The
more
the
requirements
are
shared
(i.e.
regional
or
national
scale),
the
less
impact
of
an
obstacle
the
extensions
(and
the
requirements
they
represent)
will
have.
represent.
The
consistent
representation,
definition
and
registration
of
extensions
that
this
specification
defines
cannot
resolve
that
problem
-
it
only
provides
a
framework
within
which
such
local
variations
can
be
handled
more
easily.
When
it
comes
to
deploying
applications
that
support
local
requirements,
situations
will
very
likely
arise
where
different
applications
exchanging
information
with
each
other
are
supporting
different
sets
of
extensions.
This
specification
defines
some
basic
rules
that
are
intended
to
make
management
of
these
situations
easier,
but
they
it
cannot
resolve
them.
The degree to which a system can retain unknown extensions is a function of the type of system it is: a general purpose FHIR server, or a middleware engine would be expected to retain all extensions, while an application that manages patient registration through a user interface can only retain extensions to the degree that the information in them is part of the set managed by the user. Other applications will fall somewhere between these two extremes.
Use the following rules as a guideline for handling resources:
®©
HL7.org
2011+.
FHIR
Release
3
(STU;
v3.0.2-11200)
4
(Technical
Correction
#1)
(v4.0.1)
generated
on
Thurs,
Oct
24,
Fri,
Nov
1,
2019
11:53+1100.
09:37+1100.
QA
Page
Links:
Search
|
Version
History
|
Table
of
Contents
|
Credits
|
Compare
to
DSTU2
R3
|
|
Propose
a
change