<del class="diff-old">
This
page
is
part
of
the
FHIR
Specification
(v0.0.82:
DSTU
1).
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:
R3
R2
Content
Examples
Formal
Definitions
Mappings
Profiles
6.14
Resource
Profile
-
Content
A
Resource
Profile
-
a
statement
of
use
of
one
or
more
FHIR
Resources.
It
may
include
constraints
on
Resources
and
Data
Types,
Terminology
Binding
Statements
and
Extension
Definitions.
6.14.1
Scope
and
Usage
This
specification
describes
a
set
of
base
resources
that
are
used
in
many
different
contexts
in
healthcare.
In
order
to
make
this
manageable,
applications
and
specifications
need
to
be
able
to
describe
restrictions
on
how
one
or
more
resource(s)
are
used,
including
defining
extensions,
and
controlling
how
terminology
is
used.
These
descriptions
need
to
be
able
to
be
shared
through
repositories
of
profile
definitions,
and
need
to
allow
for
these
usage
statements
to
be
published,
compared,
and
used
as
the
basis
for
code,
report
and
UI
generation.
All
these
things
are
done
using
a
&quot;Profile&quot;,
which
itself
is
represented
as
a
resource.
Profile
resources
have
three
main
parts:
A
metadata
section
the
describes
the
profile,
and
supports
registry
searching
Structures
that
define
and
describe
how
a
Resource
or
Data
Type
is
used
Extension
Definitions
that
define
extensions
that
can
be
used
in
structures
This
page
defines
the
profile
resource,
and
describes
how
it
is
used.
Note
that
as
part
of
the
specification
itself,
a
full
set
of
profiles
for
all
resources
and
data
types
is
published.
A
FHIR
RESTful
server
serving
the
profile
resource
is
also
a
profile
repository.
HL7
hosts
one
for
public
registration
of
FHIR
profiles
at
(yet
to
be
done).
6.14.2
Boundaries
and
Relationships
Profiles
are
used
by
Conformance
Profiles
for
specifying
how
resources
are
used
Profiles
use
Value
Sets
to
specify
the
content
of
coded
elements
6.14.2.1
Limitations
of
Use
A
profile
specifies
a
set
of
rules
that
the
content
of
a
resource
must
adhere
to.
In
addition,
a
resource
is
allowed
to
describe
required
behavior
for
applications
that
conform
to
the
profile.
However
the
ability
of
the
profile
to
define
this
behavior
is
limited
in
some
respects:
The
profile
cannot
specify
default
values
for
elements
It
must
be
safe
to
process
a
resource
without
knowing
of
the
profile
The
consequence
of
this
is
that
if
a
profile
mandates
behavior
that
cannot
be
ignored,
it
must
also
mandate
an
extension
with
isModifier=true
in
the
instance.
Another
way
of
saying
this
is
that
knowledge
must
be
explicit
in
the
instance,
not
implicit
in
the
profile.
As
an
example,
if
a
profile
wished
to
describe
that
any
Allergy/Intolerance
resource
was
deemed
extremely
unlikely,
it
could
not
simply
say
that
this
is
so;
instead,
it
must
say
that
the
resource
must
have
an
extension
that
represents
this
knowledge.
6.14.3
Background
and
Context
6.14.3.1
Metadata
The
profile
resource
has
a
set
of
metadata
that
is
mostly
shared
with
the
Value
Set
and
Conformance
resources.
The
metadata
describes
the
profile,
and
helps
find
the
profile
when
registered
in
profile
repositories.
identifier
The
identifier
that
is
used
to
identify
this
profile
when
it
is
referenced
in
a
specification,
model,
design
or
an
instance
(should
be
globally
unique
URI,
OID,
or
UUID)
version
The
identifier
that
is
used
to
identify
this
version
of
the
profile
when
it
is
referenced
in
a
specification,
model,
design
or
instance.
This
is
an
arbitrary
value
managed
by
the
profile
author
manually
and
the
value
should
be
a
timestamp.
Note
that
there
may
be
multiple
resource
versions
of
the
profile
that
have
this
same
identifier.
The
resource
will
have
updates
that
create
new
versions
for
technical
reasons,
whereas
the
stated
version
number
needs
to
be
under
the
author's
control
name
A
free
text
natural
language
name
identifying
the
Profile
publisher
Details
of
the
individual
or
organization
who
accepts
responsibility
for
publishing
the
profile.
This
helps
establish
the
&quot;authority/credibility&quot;
of
the
profile.
telecom
Contact
details
to
assist
a
user
in
finding
and
communicating
with
the
publisher
description
A
free
text
natural
language
description
of
the
profile
and
its
use
requirements
The
Scope
and
Usage
that
this
profile
was
created
to
meet
code
A
set
of
terms
from
external
terminologies
that
may
be
used
to
assist
with
indexing
and
searching
of
profiles
status
The
status
of
the
profile
allows
filtering
of
profiles
that
are
appropriate
for
use
vs.
not.
See
the
Status
Codes
experimental
This
profile
was
authored
for
testing
purposes
(or
education/evaluation/marketing),
and
is
not
intended
to
be
used
for
genuine
usage
date
The
date
that
this
version
of
the
profile
was
published
fhirVersion
The
version
of
the
FHIR
specification
on
which
this
profile
is
based.
It
is
not
necessary
to
specify
the
version,
as
most
profiles
are
valid
across
multiple
versions,
and
the
validity
of
a
profile
against
a
particular
version
of
FHIR
can
easily
be
checked
by
tooling.
Notes:
The
name
of
the
profile
is
not
required
to
be
globally
unique,
but
the
name
should
have
some
scoping
information
(i.e.
Acme
Inc.
(USA),
Allergy
List)
Multiple
codes
may
be
assigned
to
the
profile.
These
may
either
describe
the
profile,
the
focus
of
the
profile
or
both.
They
are
solely
to
help
find
the
profile
by
searching
for
structured
concepts.
6.14.3.2
Structure
This
section
specifies
restrictions
on
the
content
of
a
resource
or
a
data
type.
Each
structure
has
a
name,
which
as
an
internal
name
unique
in
the
scope
of
the
profile
that
is
used
to
reuse
the
structure,
and
the
type
that
it
restricts,
which
is
either
a
resource
or
data
type
defined
in
the
FHIR
specification.
The
following
kinds
of
statements
can
be
made
about
how
a
resource
or
data
type
is
used:
Restricting
the
cardinality
of
the
element.
e.g.
the
base
might
allow
0..*,
and
a
particular
application
might
support
1..2
Ruling
out
use
of
an
element
by
setting
its
maximum
cardinality
to
0
Making
additional
invariants
on
the
content
of
nested
elements
within
the
resource
(expressed
as
XPath
statements)
Restricting
the
types
for
an
element
that
allows
multiple
types
Requiring
a
typed
element
or
the
target
of
a
resource
reference
to
conform
to
a
profile
declared
elsewhere
Specifying
a
binding
to
a
different
terminology
value
set
Providing
alternative
definitions
for
the
elements
defined
in
a
Resource
to
explain
how
they
are
used
in
the
context
of
the
Profile
Providing
more
specific
or
additional
mappings
(e.g.
to
v2
or
v3)
for
the
resource
when
used
in
a
particular
context
All
of
these
changed
definitions
SHALL
be
restrictions
that
are
consistent
with
the
rules
defined
in
the
base
resource
in
the
FHIR
Specification.
Note
that
some
of
these
restrictions
can
be
enforced
by
tooling
(and
are
by
the
FHIR
tooling),
but
others
cannot
be
automatically
enforced.
A
structure
definition
consists
of
a
linear
list
of
element
declarations.
The
inherent
nested
structure
of
the
elements
is
derived
from
the
path
value
of
each
element.
For
instance,
a
sequence
of
the
element
paths
like
this:
Root
Root.childA
Root.childA.grandchild1
Root.childB
defines
the
following
structure:

 &lt;Root&gt;
   &lt;childA&gt;
     &lt;grandChild/&gt;
   &lt;/childA&gt;
   &lt;childB/&gt;
 &lt;/Root&gt;
or
its
JSON
equivalent.
The
structure
SHALL
be
coherent
-
children
are
never
implied,
and
the
path
statements
SHALL
always
be
in
order.
The
element
list
is
a
linear
list
rather
than
being
explicitly
nested
because
profile
structures
are
frequently
used
in
multiple
places
within
a
single
profile,
and
this
re-use
is
easier
in
a
flat
structure.
Profiles
are
always
complete
and
static.
This
means
that
there
is
never
a
need
to
consult
any
additional
profiles
to
fully
understand
the
element
structure
that
is
defined,
and
there
is
no
need
to
perform
comparison
between
any
profiles
to
determine
the
meaning
of
any
profile.
6.14.3.3
Slicing
One
common
feature
of
profiles
is
to
take
an
element
that
may
occur
more
than
once
(e.g.
in
a
list),
and
describe
a
series
of
different
restrictions
on
the
elements
in
the
list
with
associated
additional
meaning
with
each
element,
so
that
the
list
is
split
into
a
series
of
individual
elements
or
sub-lists.
In
FHIR,
this
operation
is
known
as
&quot;Slicing&quot;
a
collection.
Here
is
an
example
to
illustrate
the
process:
In
this
example,
the
base
resource
defines
the
&quot;related&quot;
element
which
may
occur
multiple
times.
Each
related
element
has
a
&quot;type&quot;
element,
and
a
&quot;target&quot;
element
which
identifies
another
observation.
In
this
diagram,
the
contents
of
the
target
element
are
shown
in
the
inner
box
instead
of
the
showing
the
target
reference
explicitly.
Note
that
to
avoid
adding
clutter
to
this
simplified
example,
the
&quot;name&quot;
attribute
of
Observation
is
shown
as
(code)
not
a
full
CodeableConcept.
The
profile
for
Blood
Pressure
constrains
the
related
element
list
into
2
different
elements:
a
systolic
element,
and
a
diastolic
element.
Each
of
these
elements
has
a
fixed
value
for
the
type
element,
and
a
the
profile
also
fixes
the
contents
of
the
target
observation
as
well,
specifying
a
fixed
LOINC
code
for
the
name,
and
specifying
that
both
have
a
value
of
type
Quantity.
This
process
is
known
as
&quot;slicing&quot;
and
the
Systolic
and
Diastolic
elements
are
called
&quot;slices&quot;.
Note
that
when
the
resource
is
exchanged,
the
wire
format
that
is
exchanged
is
not
altered
by
the
profile.
This
means
that
the
item
profile
names
defined
in
the
profile
(&quot;systolic&quot;,
etc.
in
this
example)
are
never
exchanged.
A
resource
instance
looks
like
this:

 &lt;Observation&gt;
   ...
   &lt;related&gt;
     &lt;type value=&quot;component&quot;/&gt;
     &lt;target ...&gt;
   &lt;/related&gt;
   &lt;related&gt;
     &lt;type value=&quot;component&quot;/&gt;
     &lt;target ...&gt;
   &lt;/related&gt;
 &lt;/Observation&gt;
The
only
way
to
determine
that
the
first
related
item
corresponds
to
&quot;Systolic&quot;
in
the
profile
is
to
check
the
values
of
the
elements
-
in
this
case,
the
name
element
in
the
target
resource.
In
order
to
make
slicing
easy
to
use,
particularly
in
the
context
of
code
generation
tools
that
work
with
profiles,
any
time
slicing
is
performed
in
a
profile,
the
profile
SHALL
nominate
a
&quot;discriminator&quot;
-
a
contained
element
that
is
used
to
discriminate
among
the
different
slices.
The
profile
SHALL
fix
the
value
of
the
contained
element
for
each
slice,
or
if
the
contained
element
has
a
terminology
binding,
it
SHALL
be
associated
with
a
complete
binding
with
a
version
specific
Value
Set
reference
that
enumerates
the
possible
codes
in
the
value
set,
and
where
there
is
no
overlap
between
the
codes
in
the
value
sets
between
slices.
Within
a
profile,
a
slice
is
defined
using
multiple
element
entries
that
share
a
path
but
have
distinct
name
s.
These
entries
together
form
a
&quot;slice
group&quot;
that
is:
Initiated
by
a
&quot;slicing
entry&quot;
That
is,
the
first
element
in
a
slice
group
must
contain
a
slicing
property
that
defines
the
discriminator
for
all
members
of
the
group.
Mutually
exclusive
.
This
means
that
each
element
in
a
slice
group
SHALL
describe
a
distinct
set
of
values
for
the
group's
discriminator
.
Because
of
this
constraint,
an
element
in
a
resource
instance
will
never
match
more
than
one
element
in
a
given
slice
group.
Serialized
as
a
group
.
The
entries
in
a
slice
group
must
be
adjacent
in
a
serialized
Profile,
or
,
if
there
are
any
intervening
elements,
those
elements
must
be
&quot;compatible
with&quot;
the
group.
Concretely,
this
means
that
any
intervening
elements
must
have
a
path
that
starts
with
the
slice
groups's
path
.
For
example,
an
element
with
a
path
of
Observation.name.extension
would
be
compatible
with
(and
thus,
would
not
&quot;break
up&quot;)
a
slice
group
whose
path
was
Observation.name
The
value
of
the
discriminator
is
either
a
path
name
that
identifies
the
child
element
using
a
dotted
notation,
or
a
URI,
which
identifies
an
extension
that
serves
as
the
discriminator
(and
which
must
be
found
on
the
element
at
which
the
slicing
occurs).
In
the
case
above,
the
discriminator
is
&quot;target.name&quot;
(the
fact
that
there
is
a
resource
boundary
between
&quot;target&quot;
and
&quot;name&quot;
is
implied,
not
represented
directly).
6.14.3.4
Extension
Definitions
A
profile
can
also
define
extensions.
Some
profiles
only
define
extensions,
and
others
define
extensions
as
part
of
defining
one
or
more
structures.
For
an
extension
definition,
the
profile
defines
the
code
that
identifies
the
extension.
The
full
URI
that
refers
to
the
extension
when
it
is
used
in
a
resource
is
the
identifier
(from
the
metadata
above)
and
then
#
+
the
code.
The
extension
definition
also
defines
the
context
where
the
extension
can
be
used
(usually
a
particular
path
or
a
data
type),
and
then
defines
it
using
the
same
details
used
to
profile
the
structural
elements.
Note
that
in
the
case
of
a
profile
that
defines
an
extension,
and
then
uses
it,
the
extension
will
appear
both
in
the
extension
definition
section,
and
in
one
or
more
places
in
the
structure
defined
by
the
profile.
For
further
discussion
of
defining
and
using
extensions,
along
with
some
examples,
see
Extensibility
.
6.14.3.4.1
Using
Extensions
in
Structures
Defining
a
extension
means
that
it
can
be
used
in
a
resource
somewhere.
To
actually
use
a
resource,
the
extension
list
on
the
resource
needs
to
be
sliced.
This
is
shown
in
the
extensibility
examples
Note
that
the
minimum
cardinality
of
an
extension
SHALL
be
a
valid
restriction
on
the
minimum
cardinality
in
the
definition
of
the
extension.
if
the
minimum
cardinality
of
the
extension
is
1
when
it
is
defined,
it
can
only
be
mandatory
when
it
is
added
to
a
profile.
This
is
not
recommended
-
the
minimum
cardinality
of
an
extension
should
be
0.
6.14.3.5
Binding
Definitions
Coded
elements
have
bindings
that
link
from
the
element
to
a
definition
of
the
set
of
possible
codes
the
element
may
contain.
The
binding
identifies
the
definition
of
the
set
of
possible
codes,
and
controls
how
tightly
the
set
of
the
possible
codes
is
interpreted.
The
set
of
possible
codes
is
either
a
formal
reference
to
a
value
set
resource,
which
may
be
version
specific,
or
a
general
reference
to
some
web
content
that
defines
a
set
of
codes.
The
second
is
most
appropriate
where
set
of
values
is
defined
by
some
external
standard
(such
as
mime
types).
Alternatively,
where
the
binding
is
incomplete
(e.g.
under
development)
just
a
text
description
of
the
possible
codes
can
be
provided.
Bindings
have
two
properties
that
define
how
the
set
of
codes
is
used:
isExtensible
and
conformance
.
isExtensible
indicates
whether
additional
codes
are
allowed
beyond
those
in
the
defined
set
of
codes.
false
No
additional
codes
are
to
be
used
beyond
the
list
provided
true
Supplemental
codes
or
plain
text
may
be
needed
(this
is
common
because
it
is
reasonable
to
think
that
concepts
will
need
to
be
used
which
won't
be
in
the
defined
set
of
codes)
Conformance
indicates
the
expectations
for
implementers
of
the
specification.
There
are
three
possible
values:
required
Only
codes
in
the
specified
set
are
allowed.
If
the
strength
is
'extensible',
other
codes
may
be
used
for
concepts
not
covered
by
the
value
set
but
cannot
be
used
for
concepts
covered
by
the
bound
code
list,
even
if
a
profile
constrains
out
some
of
those
codes).
preferred
For
greater
interoperability,
implementers
are
strongly
encouraged
to
use
the
bound
set
of
codes,
however
alternate
codes
may
be
used
in
profiles
if
necessary
without
being
considered
non-conformant.
example
The
codes
in
the
set
are
an
example
to
illustrate
the
meaning
of
the
field.
There
is
no
particular
preference
for
its
use.
The
interplay
between
the
meaning
of
these
is
subtle
but
sometimes
important.
The
following
table
helps
define
the
meanings:
Conformance
isExtensible=false
isExtensible=true
Required
Implementers
SHALL
use
a
code
from
the
defined
set
Implementers
SHALL
use
a
code
from
the
defined
set
if
one
is
applicable,
but
otherwise
may
provide
their
own
code
or
use
text
Preferred
Implementers
SHOULD
use
a
code
from
the
defined
set
Implementers
SHOULD
use
a
code
from
the
defined
set
if
one
is
applicable,
but
MAY
provide
their
own
code
or
use
text
Example
Implementers
MAY
use
a
code
from
the
defined
set
Implementers
MAY
use
a
code
from
the
defined
set
or
provide
their
own
code
or
use
text
A
profile
can
define
a
set
of
bindings
that
it
uses
directly,
or
it
can
define
a
set
of
bindings
for
re-use
in
other
profiles.
To
use
bindings
in
other
profiles,
just
provide
an
absolute
reference.
This
is
a
reference
to
a
binding
in
the
same
profile:

  &lt;binding value=&quot;te:OperationOutcomeSource&quot;/&gt;
This
is
a
reference
to
a
binding
in
some
other
profile:

  &lt;binding value=&quot;http://hl7.org/fhir/tooling/extensions#OperationOutcomeSource&quot;/&gt;
Bindings
can
reference
value
sets
by
version
or
independent
of
version.
Value
sets
may
themselves
reference
other
value
sets
as
well
as
code
systems
by
version
or
independent
of
version.
Unless
all
references
are
version-specific,
it
is
possible
that
the
set
of
codes
permitted
in
the
value
set
could
change
over
time.
6.14.4
Resource
Content
Profile
(
Resource
)
The
identifier
that
is
used
to
identify
this
profile
when
it
is
referenced
in
a
specification,
model,
design
or
an
instance
(should
be
globally
unique
OID,
UUID,
or
URI)
identifier
:
string
0..1
The
identifier
that
is
used
to
identify
this
version
of
the
profile
when
it
is
referenced
in
a
specification,
model,
design
or
instance.
This
is
an
arbitrary
value
managed
by
the
profile
author
manually
and
the
value
should
be
a
timestamp
version
:
string
0..1
A
free
text
natural
language
name
identifying
the
Profile
name
:
string
1..1
Details
of
the
individual
or
organization
who
accepts
responsibility
for
publishing
the
profile
publisher
:
string
0..1
Contact
details
to
assist
a
user
in
finding
and
communicating
with
the
publisher
telecom
:
Contact
0..*
A
free
text
natural
language
description
of
the
profile
and
its
use
description
:
string
0..1
A
set
of
terms
from
external
terminologies
that
may
be
used
to
assist
with
indexing
and
searching
of
templates
code
:
Coding
0..*
The
status
of
the
profile
(this
element
modifies
the
meaning
of
other
elements)
status
:
code
1..1
&lt;&lt;
The
lifecycle
status
of
a
Resource
Profile
ResourceProfileStatus
&gt;&gt;
This
profile
was
authored
for
testing
purposes
(or
education/evaluation/marketing),
and
is
not
intended
to
be
used
for
genuine
usage
experimental
:
boolean
0..1
The
date
that
this
version
of
the
profile
was
published
date
:
dateTime
0..1
The
Scope
and
Usage
that
this
profile
was
created
to
meet
requirements
:
string
0..1
The
version
of
the
FHIR
specification
on
which
this
profile
is
based
fhirVersion
:
id
0..1
Mapping
An
Internal
id
that
is
used
to
identify
this
mapping
set
when
specific
mappings
are
made
identity
:
id
1..1
A
URI
that
identifies
the
specification
that
this
mapping
is
expressed
to
uri
:
uri
0..1
A
name
for
the
specification
that
is
being
mapped
to
name
:
string
0..1
Comments
about
this
mapping,
including
version
notes,
issues,
scope
limitations,
and
other
important
notes
for
usage
comments
:
string
0..1
Structure
The
Resource
or
Data
type
being
described
type
:
code
1..1
&lt;&lt;
Either
a
resource
or
a
data
type
FHIRDefinedType
&gt;&gt;
The
name
of
this
resource
constraint
statement
(to
refer
to
it
from
other
resource
constraints
-
from
Profile.structure.element.definition.type.profile)
name
:
string
0..1
This
definition
of
a
profile
on
a
structure
is
published
as
a
formal
statement.
Some
structural
definitions
might
be
defined
purely
for
internal
use
within
the
profile,
and
not
intended
to
be
used
outside
that
context
publish
:
boolean
0..1
Human
summary:
why
describe
this
resource?
purpose
:
string
0..1
Element
The
path
identifies
the
element
and
is
expressed
as
a
&quot;.&quot;-separated
list
of
ancestor
elements,
beginning
with
the
name
of
the
resource
path
:
string
1..1
Codes
that
define
how
this
element
is
represented
in
instances,
when
the
deviation
varies
from
the
normal
case
representation
:
code
0..*
&lt;&lt;
How
a
property
is
represented
on
the
wire
PropertyRepresentation
&gt;&gt;
The
name
of
this
element
definition
(to
refer
to
it
from
other
element
definitions
using
Profile.structure.element.definition.nameReference).
This
is
a
unique
name
referring
to
a
specific
set
of
constraints
applied
to
this
element.
One
use
of
this
is
to
provide
a
name
to
different
slices
of
the
same
element
name
:
string
0..1
Slicing
Designates
which
child
element
is
used
to
discriminate
between
the
slices
when
processing
an
instance.
The
value
of
the
child
element
in
the
instance
SHALL
completely
distinguish
which
slice
the
element
in
the
resource
matches
based
on
the
allowed
values
for
that
element
in
each
of
the
slices
discriminator
:
id
1..1
If
the
matching
elements
have
to
occur
in
the
same
order
as
defined
in
the
profile
ordered
:
boolean
1..1
Whether
additional
slices
are
allowed
or
not.
When
the
slices
are
ordered,
profile
authors
can
also
say
that
additional
slices
are
only
allowed
at
the
end
rules
:
code
1..1
&lt;&lt;
How
slices
are
interpreted
when
evaluating
an
instance
SlicingRules
&gt;&gt;
ElementDefinition
A
concise
definition
that
is
shown
in
the
generated
XML
format
that
summarizes
profiles
(used
throughout
the
specification)
short
:
string
1..1
The
definition
SHALL
be
consistent
with
the
base
definition,
but
convey
the
meaning
of
the
element
in
the
particular
context
of
use
of
the
resource
formal
:
string
1..1
Comments
about
the
use
of
the
element,
including
notes
about
how
to
use
the
data
properly,
exceptions
to
proper
use,
etc
comments
:
string
0..1
Explains
why
this
element
is
needed
and
why
it's
been
constrained
as
it
has
requirements
:
string
0..1
Identifies
additional
names
by
which
this
element
might
also
be
known
synonym
:
string
0..*
The
minimum
number
of
times
this
element
SHALL
appear
in
the
instance
min
:
integer
1..1
The
maximum
number
of
times
this
element
is
permitted
to
appear
in
the
instance
max
:
string
1..1
Identifies
the
name
of
a
slice
defined
elsewhere
in
the
profile
whose
constraints
should
be
applied
to
the
current
element
nameReference
:
string
0..1
Specifies
a
primitive
value
that
SHALL
hold
for
this
element
in
the
instance
value[x]
:
*
0..1
An
example
value
for
this
element
example[x]
:
*
0..1
Indicates
the
shortest
length
that
SHALL
be
supported
by
conformant
instances
without
truncation
maxLength
:
integer
0..1
A
reference
to
an
invariant
that
may
make
additional
statements
about
the
cardinality
or
value
in
the
instance
condition
:
id
0..*
If
true,
conformant
resource
authors
SHALL
be
capable
of
providing
a
value
for
the
element
and
resource
consumers
SHALL
be
capable
of
extracting
and
doing
something
useful
with
the
data
element.
If
false,
the
element
may
be
ignored
and
not
supported
mustSupport
:
boolean
0..1
If
true,
the
value
of
this
element
affects
the
interpretation
of
the
element
or
resource
that
contains
it,
and
the
value
of
the
element
cannot
be
ignored.
Typically,
this
is
used
for
status,
negation
and
qualification
codes.
The
effect
of
this
is
that
the
element
cannot
be
ignored
by
systems:
they
SHALL
either
recognize
the
element
and
process
it,
and/or
a
pre-determination
has
been
made
that
it
is
not
relevant
to
their
particular
system
isModifier
:
boolean
1..1
TypeRef
Name
of
Data
type
or
Resource
code
:
code
1..1
&lt;&lt;
The
type
of
an
element
-
one
of
the
FHIR
data
types
DataType
&gt;&gt;
Identifies
a
profile
that
SHALL
hold
for
resources
or
datatypes
referenced
as
the
type
of
this
element.
Can
be
a
local
reference
-
to
another
structure
in
this
profile,
or
a
reference
to
a
structure
in
another
profile
profile
:
uri
0..1
If
the
type
is
a
reference
to
another
resource,
how
the
resource
is
or
can
be
aggreated
-
is
it
a
contained
resource,
or
a
reference,
and
if
the
context
is
a
bundle,
is
it
included
in
the
bundle
aggregation
:
code
0..*
&lt;&lt;
How
resource
references
can
be
aggregated
AggregationMode
&gt;&gt;
Constraint
Allows
identification
of
which
elements
have
their
cardinalities
impacted
by
the
constraint.
Will
not
be
referenced
for
constraints
that
do
not
affect
cardinality
key
:
id
1..1
Used
to
label
the
constraint
in
OCL
or
in
short
displays
incapable
of
displaying
the
full
human
description
name
:
string
0..1
Identifies
the
impact
constraint
violation
has
on
the
conformance
of
the
instance
severity
:
code
1..1
&lt;&lt;
SHALL
applications
comply
with
this
constraint?
ConstraintSeverity
&gt;&gt;
Text
that
can
be
used
to
describe
the
constraint
in
messages
identifying
that
the
constraint
has
been
violated
human
:
string
1..1
XPath
expression
of
constraint
xpath
:
string
1..1
Binding
A
descriptive
name
for
this
-
can
be
useful
for
generating
implementation
artifacts
name
:
string
1..1
If
true,
then
conformant
systems
may
use
additional
codes
or
(where
the
data
type
permits)
text
alone
to
convey
concepts
not
covered
by
the
set
of
codes
identified
in
the
binding.
If
false,
then
conformant
systems
are
constrained
to
the
provided
codes
alone
isExtensible
:
boolean
1..1
Indicates
the
degree
of
conformance
expectations
associated
with
this
binding
conformance
:
code
0..1
&lt;&lt;
Binding
conformance
for
applications
BindingConformance
&gt;&gt;
Describes
the
intended
use
of
this
particular
set
of
codes
description
:
string
0..1
Points
to
the
value
set
or
external
definition
that
identifies
the
set
of
codes
to
be
used
reference[x]
:
uri
|
Resource
(
ValueSet
)
0..1
Mapping
An
internal
reference
to
the
definition
of
a
mapping
identity
:
id
1..1
Expresses
what
part
of
the
target
specification
corresponds
to
this
element
map
:
string
1..1
SearchParam
The
name
of
the
standard
or
custom
search
parameter
name
:
string
1..1
The
type
of
value
a
search
parameter
refers
to,
and
how
the
content
is
interpreted
type
:
code
1..1
&lt;&lt;
Data
types
allowed
to
be
used
for
search
parameters
SearchParamType
&gt;&gt;
A
specification
for
search
parameters.
For
standard
parameters,
provides
additional
information
on
how
the
parameter
is
used
in
this
solution.
For
custom
parameters,
provides
a
description
of
what
the
parameter
does
documentation
:
string
1..1
An
XPath
expression
that
returns
a
set
of
elements
for
the
search
parameter
xpath
:
string
0..1
Types
of
resource
(if
a
resource
is
referenced)
target
:
code
0..*
&lt;&lt;
One
of
the
resource
types
defined
as
part
of
FHIR
ResourceType
&gt;&gt;
ExtensionDefn
A
unique
code
(within
the
profile)
used
to
identify
the
extension
code
:
code
1..1
Defined
so
that
applications
can
use
this
name
when
displaying
the
value
of
the
extension
to
the
user
display
:
string
0..1
Identifies
the
type
of
context
to
which
the
extension
applies
contextType
:
code
1..1
&lt;&lt;
How
an
extension
context
is
interpreted
ExtensionContext
&gt;&gt;
Identifies
the
types
of
resource
or
data
type
elements
to
which
the
extension
can
be
applied
context
:
string
1..*
Query
The
name
of
a
query,
which
is
used
in
the
URI
from
Conformance
statements
declaring
use
of
the
query.
Typically
this
will
also
be
the
name
for
the
_query
parameter
when
the
query
is
called,
though
in
some
cases
it
may
be
aliased
by
a
server
to
avoid
collisions
name
:
string
1..1
Description
of
the
query
-
the
functionality
it
offers,
and
considerations
about
how
it
functions
and
to
use
it
documentation
:
string
1..1
An
external
specification
that
the
content
is
mapped
to
mapping
0..*
Indicates
that
the
element
is
sliced
into
a
set
of
alternative
definitions
(there
are
multiple
definitions
on
a
single
element
in
the
base
resource).
The
set
of
slices
is
any
elements
that
come
after
this
in
the
element
sequence
that
have
the
same
path,
until
a
shorter
path
occurs
(the
shorter
path
terminates
the
set)
slicing
0..1
The
data
type
or
resource
that
the
value
of
this
element
is
permitted
to
be
type
0..*
Formal
constraints
such
as
co-occurrence
and
other
constraints
that
can
be
computationally
evaluated
within
the
context
of
the
instance
constraint
0..*
Binds
to
a
value
set
if
this
element
is
coded
(code,
Coding,
CodeableConcept)
binding
0..1
Identifies
a
concept
from
an
external
specification
that
roughly
corresponds
to
this
element
mapping
0..*
Definition
of
the
content
of
the
element
to
provide
a
more
specific
definition
than
that
contained
for
the
element
in
the
base
resource
definition
0..1
Captures
constraints
on
each
element
within
the
resource
element
0..*
Additional
search
parameters
for
implementations
to
support
and/or
make
use
of
searchParam
0..*
A
constraint
statement
about
what
contents
a
resource
or
data
type
may
have
structure
0..*
Definition
of
the
extension
and
its
content
definition
1..1
An
extension
defined
as
part
of
the
profile
extensionDefn
0..*
A
parameter
of
a
named
query
parameter
0..*
Definition
of
a
named
query
and
its
parameters
and
their
meaning
query
0..*
This
resource
is
referenced
by
[Conformance]

&lt;
 &lt;!-- from  --&gt;
 &lt;
 &lt;
 &lt;
 &lt;
 &lt;&lt;/telecom&gt;
 &lt;
 &lt;&lt;/code&gt;
 &lt;
 &lt;
 &lt;
 &lt;
 &lt;
 &lt;
  &lt;
  &lt;
  &lt;
  &lt;
 &lt;/mapping&gt;
 &lt;
  &lt;
  &lt;
  &lt;
  &lt;
  &lt;
   &lt;
   &lt;
   &lt;
   &lt;
    &lt;
    &lt;
    &lt;
   &lt;/slicing&gt;
   &lt;
    &lt;
    &lt;
    &lt;
    &lt;
    &lt;
    &lt;
    &lt;
    &lt;
     &lt;
     &lt;
     &lt;
    &lt;/type&gt;
    &lt;
    &lt;&lt;/value[x]&gt;
    &lt;&lt;/example[x]&gt;
    &lt;
    &lt;
    &lt;
     &lt;
     &lt;
     &lt;
     &lt;
     &lt;
    &lt;/constraint&gt;
    &lt;
    &lt;
    &lt;
     &lt;
     &lt;
     &lt;
     &lt;
     &lt;&lt;/reference[x]&gt;
    &lt;/binding&gt;
    &lt;
     &lt;
     &lt;
    &lt;/mapping&gt;
   &lt;/definition&gt;
  &lt;/element&gt;
  &lt;
   &lt;
   &lt;
   &lt;
   &lt;
   &lt;
  &lt;/searchParam&gt;
 &lt;/structure&gt;
 &lt;
  &lt;
  &lt;
  &lt;
  &lt;
  &lt;&lt;/definition&gt;
 &lt;/extensionDefn&gt;
 &lt;
  &lt;
  &lt;
  &lt;&lt;/parameter&gt;
 &lt;/query&gt;
&lt;/Profile&gt;
Alternate
definitions:
Schema
/
Schematron
,
Resource
Profile
6.14.4.1
Terminology
Bindings
Path
Definition
Type
Reference
Profile.status
The
lifecycle
status
of
a
Resource
Profile
Fixed
http://hl7.org/fhir/resource-profile-status
Profile.structure.type
Either
a
resource
or
a
data
type
Incomplete
http://hl7.org/fhir/defined-types
Profile.structure.element.representation
How
a
property
is
represented
on
the
wire
Fixed
http://hl7.org/fhir/property-representation
Profile.structure.element.slicing.rules
How
slices
are
interpreted
when
evaluating
an
instance
Fixed
http://hl7.org/fhir/resource-slicing-rules
Profile.structure.element.definition.type.code
The
type
of
an
element
-
one
of
the
FHIR
data
types
Incomplete
http://hl7.org/fhir/data-types
Profile.structure.element.definition.type.aggregation
How
resource
references
can
be
aggregated
Fixed
http://hl7.org/fhir/resource-aggregation-mode
Profile.structure.element.definition.constraint.severity
SHALL
applications
comply
with
this
constraint?
Fixed
http://hl7.org/fhir/constraint-severity
Profile.structure.element.definition.binding.conformance
Binding
conformance
for
applications
Fixed
http://hl7.org/fhir/binding-conformance
Profile.structure.searchParam.type
Data
types
allowed
to
be
used
for
search
parameters
Fixed
http://hl7.org/fhir/search-param-type
Profile.structure.searchParam.target
One
of
the
resource
types
defined
as
part
of
FHIR
Incomplete
http://hl7.org/fhir/resource-types
Profile.extensionDefn.contextType
How
an
extension
context
is
interpreted
Fixed
http://hl7.org/fhir/extension-context
6.14.4.2
Constraints
Inv-8
:
SHALL
define
at
least
one
structure
constraint
or
extension
definition
(xpath:
exists(f:structure)
or
exists(f:extensionDefn)
)
Inv-15
:
Where
multiple
structures
exist
with
the
same
type,
they
SHALL
have
names
(xpath:
count(f:structure[not(f:name)])
=
count(distinct-values(f:structure[not(f:name)]/f:type/@value))
)
Inv-16
:
Extension
definition
codes
must
be
unique
(xpath:
count(f:extensionDefn)
=
count(distinct-values(f:extensionDefn/f:code/@value))
)
Inv-17
:
There
can't
be
multiple
structures
with
the
same
type
and
name
(xpath:
not(exists(for
$structure
in
f:structure
return
$structure/preceding-sibling::f:structure[f:type/@value=$structure/f:type/@value
and
f:name/@value
=
$structure/f:name/@value]))
)
Inv-27
:
Structure
name
must
be
unique
(xpath:
count(distinct-values(f:structure/f:name/@value))
=count(f:structure/f:name)
)
Inv-28
:
Query
name
must
be
unique
(xpath:
count(distinct-values(f:query/f:name/@value))
=count(f:query/f:name)
)
Inv-26
:
On
Profile.mapping:
Must
have
at
a
name
or
a
uri
(or
both)
(xpath
on
f:Profile/f:mapping:
exists(f:uri)
or
exists(f:name)
)
Inv-12
:
On
Profile.structure:
Only
complex
types
can
be
constrained,
not
primitive
types
such
as
string
etc.
(xpath
on
f:Profile/f:structure:
upper-case(substring(f:type,1,1))=substring(f:type,1,1)
)
Inv-18
:
On
Profile.structure:
Element
paths
must
be
unique
-
or
not
(LM)
(xpath
on
f:Profile/f:structure:
count(f:element)
&gt;=
count(distinct-values(f:element/f:path/@value))
)
Inv-29
:
On
Profile.structure:
Parameter
names
must
be
unique
within
structure
(xpath
on
f:Profile/f:structure:
count(distinct-values(f:searchParam/f:name/@value))
=count(f:searchParam/f:name)
)
Inv-11
:
On
Profile.structure.element:
Must
have
either
a
slice
or
a
definition,
but
not
both
(xpath
on
f:Profile/f:structure/f:element:
exists(f:slicing)
!=
exists(f:definition)
)
Inv-20
:
On
Profile.structure.element:
An
element
must
either
be
a
definition
or
a
slicing
descriptor,
never
both.
(xpath
on
f:Profile/f:structure/f:element:
exists(f:slicing)!=exists(f:definition)
)
Inv-21
:
On
Profile.structure.element:
An
element
that's
a
slicing
descriptor
must
not
be
preceded
by
an
element
that
starts
with
the
same
path
and
must
be
followed
by
an
element
with
exactly
the
same
path.
(xpath
on
f:Profile/f:structure/f:element:
not(f:slicing)
or
(not(starts-with(preceding-sibling::f:element[1]/f:path/@value,
current()/f:path/@value))
and
following-sibling::f:element[1]/f:path/@value=current()/f:path/@value)
)
Inv-2
:
On
Profile.structure.element.definition:
Either
a
namereference
or
a
fixed
value
(but
not
both)
is
permitted
(xpath
on
f:Profile/f:structure/f:element/f:definition:
not(exists(f:nameReference)
and
exists(f:*[starts-with(local-name(.),
'value')]))
)
Inv-7
:
On
Profile.structure.element.definition:
Binding
can
only
be
present
for
coded
elements
(xpath
on
f:Profile/f:structure/f:element/f:definition:
not(exists(f:binding))
or
f:type/f:code/@value=('code','Coding','CodeableConcept','Quantity')
)
Inv-10
:
On
Profile.structure.element.definition:
Value
may
only
be
specified
if
the
type
consists
of
a
single
repetition
that
has
a
type
corresponding
to
one
of
the
primitive
data
types.
(xpath
on
f:Profile/f:structure/f:element/f:definition:
not(exists(f:*[starts-with(local-name(.),
'value')]))
or
(count(f:type)=1
and
f:type/f:code[substring(@value,1,1)=lower-case(substring(@value,1,1))])
)
Inv-19
:
On
Profile.structure.element.definition:
Element
names
must
be
unique
(xpath
on
f:Profile/f:structure/f:element/f:definition:
count(f:element[f:name])
=
count(distinct-values(f:element/f:name/@value))
)
Inv-22
:
On
Profile.structure.element.definition:
If
a
definition
has
multiple
types
with
the
same
code,
each
must
specify
a
profile
(xpath
on
f:Profile/f:structure/f:element/f:definition:
count(f:type[not(f:profile)])
=
count(distinct-values(f:type[not(f:profile)]/f:code/@value))
)
Inv-23
:
On
Profile.structure.element.definition:
Types
must
be
unique
by
the
combination
of
code
and
profile
(xpath
on
f:Profile/f:structure/f:element/f:definition:
not(exists(for
$type
in
f:type
return
$type/preceding-sibling::f:type[f:code/@value=$type/f:code/@value
and
f:profile/@value
=
$type/f:profile/@value]))
)
Inv-24
:
On
Profile.structure.element.definition:
Constraints
must
be
unique
by
key
(xpath
on
f:Profile/f:structure/f:element/f:definition:
count(f:constraint)
=
count(distinct-values(f:constraint/f:key/@value))
)
Inv-25
:
On
Profile.structure.element.definition:
Constraint
names
must
be
unique.
(xpath
on
f:Profile/f:structure/f:element/f:definition:
count(f:constraint[f:name])
=
count(distinct-values(f:constraint/f:name/@value))
)
Inv-6
:
On
Profile.structure.element.definition.max:
Max
SHALL
be
a
number
or
&quot;*&quot;
(xpath
on
f:Profile/f:structure/f:element/f:definition/f:max:
@value='*'
or
(normalize-space(@value)!=''
and
normalize-space(translate(@value,
'0123456789',''))='')
)
Inv-9
:
On
Profile.structure.element.definition.type:
Aggregation
may
only
be
specified
if
one
of
the
allowed
types
for
the
element
is
a
resource
(xpath
on
f:Profile/f:structure/f:element/f:definition/f:type:
not(exists(f:aggregation))
or
exists(f:code[starts-with(@value,
'Resource(')])
)
Inv-3
:
On
Profile.structure.element.definition.binding:
provide
either
a
reference
or
a
description
(or
both)
(xpath
on
f:Profile/f:structure/f:element/f:definition/f:binding:
(exists(f:referenceUri)
or
exists(f:referenceResource))
or
exists(f:description)
)
Inv-14
:
On
Profile.structure.element.definition.binding:
Example
value
sets
are
always
extensible
(xpath
on
f:Profile/f:structure/f:element/f:definition/f:binding:
not(f:Conformance/value='example'
and
f:isExtensible.value='false')
)
Inv-13
:
On
Profile.structure.element.definition.binding.reference[x]:
uri
SHALL
start
with
http://
or
https://
(xpath
on
f:Profile/f:structure/f:element/f:definition/f:binding/f:reference[x]:
starts-with(@value,
'http:')
or
starts-with(@value,
'https:')
)
Inv-5
:
On
Profile.extensionDefn.code:
Codes
SHALL
be
unique
in
the
context
of
a
profile
(xpath
on
f:Profile/f:extensionDefn/f:code:
count(ancestor::f:Profile/f:extensionDefn/f:code[@value=current()/@value])=1
)
6.14.5
Interpretation
Notes:
The
name
of
a
resource
constraint
(Profile.structure.name)
is
used
as
a
logical
target
for
both
internal
and
external
references
to
the
profile.
A
internal
reference
is
made
from
Profile.structure.element.definition.type.profile
to
re-use
the
constraints
declared
in
another
structure,
either
in
the
same
profile
or
another.
If
the
reference
is
within
the
same
resource,
the
uri
is
a
relative
reference
with
the
form
#[name].
If
the
reference
is
to
another
resource,
it
should
be
either
an
absolute
URI
that
termintes
with
a
#[name]
An
external
reference
is
one
made
to
the
profile
from
a
Conformance
Statement
or
a
Profile
Tag
.
For
these
references,
the
[#name]
portion
is
optional.
If
there
is
no
#name
portion,
the
reference
doesn't
identify
a
particular
structural
definition
in
the
instance,
and
it
is
an
error
if
there
is
more
than
one
matching
structure
for
the
resource
type
in
context
that
might
apply
when
the
Profile
reference
is
used
The
constraint
statement
has
a
flat
list
of
elements.
The
path
element
provides
the
overall
structure
and
it
SHALL
match
the
structure
and
names
in
the
resource
structure
exactly.
The
condition
element
is
used
to
assert
that
a
constraint
defined
on
another
element
affects
the
allowed
cardinality
of
this
element.
The
type
is
used
to
specify
which
types
apply
when
the
underlying
resource
allows
a
choice
of
types.
When
the
type
of
the
element
is
fixed
in
the
underlying
resource
definitions,
it
should
still
be
stated
in
the
profile.
The
type
is
optional
because
repeating
groups
of
elements
do
not
have
a
type.
The
definition
(short,
formal,
comments
and
the
mappings)
for
an
element
is
provided
so
that
the
resource
profile
can
provide
a
more
specific
definition
for
the
field
in
a
specific
context.
For
instance,
the
underlying
resource
definition
might
be
&quot;Result
value&quot;
and
the
more
specific
resource
definition
could
be
&quot;Plasma
Cholesterol
Test
Value&quot;.
The
meaning
needs
to
be
consistent
with
the
underlying
definition,
but
narrower
-
a
constraint
on
it.
For
an
element
with
a
maximum
cardinality
of
1,
there
can
only
be
one
entry
in
the
value
list,
which
is
either
a
literal
fixed
type
(with
an
element
name
matching
the
type
of
the
fixed
value)
or
a
name,
which
is
a
reference
to
a
named
constraint
pattern.
If
the
element
has
a
maximum
cardinality
of
&gt;1,
then
there
can
be
multiple
values
-
again,
either
fixed
values
with
a
type
or
a
named
constraint.
Each
of
these
appears
in
the
list
with
the
order
and
cardinality
specified.
By
this
means,
a
list
may
be
&quot;sliced&quot;
into
a
series
of
different
components.
There
can
be
more
than
one
entry
for
each
element
path.
The
constraint
specification
can
define
multiple
different
constraints
for
any
element
and
then
use
them
in
different
places.
In
practice,
this
is
useful
when
slicing
a
list
and
the
differently
named
constraint
profiles
are
differentiated
using
the
value[x]
element.
The
name
of
the
element
constraint
SHALL
be
unique
within
the
constraint
specification
for
that
resource.
If
a
constraint
does
not
have
a
name,
it
applies
to
the
base
resource
and
SHALL
be
found
in
the
correct
place
in
the
structure.
Closed
is
only
relevant
if
the
underlying
element
has
a
max
cardinality
&gt;
1.
For
an
extension
definition,
the
cardinality
constraints
are
limits
on
the
constraints
of
any
reference
to
the
extension
in
a
profile.
For
example,
if
the
minimum
cardinality
of
an
extension
is
1
when
it
is
defined,
then
any
profile
that
includes
that
extension
in
the
instance
SHALL
include
it
with
a
minimum
cardinality
of
1
and
therefore
any
instance
that
conforms
to
the
profile
SHALL
include
the
extension.
Note,
however,
that
if
the
extension
is
simply
directly
referenced
in
an
instance
rather
than
applied
through
a
profile,
the
minimum
cardinality
doesn't
apply,
though
the
maximum
one
still
does.
For
xpath
constraints,
the
prefix
&quot;f&quot;
should
be
used
for
&quot;http://hl7.org/fhir&quot;,
and
&quot;h&quot;
for
&quot;http://www.w3.org/1999/xhtml&quot;.
XPath
constraints
are
written
against
the
XML
representation,
but
SHALL
be
true
in
any
other
representation
as
well
When
using
xpath
to
make
constraints
about
the
relationship
between
the
contents
of
the
narrative
and
the
contents
of
the
data
elements,
the
element
against
which
the
rule
is
expressed
is
the
one
against
which
the
error
will
be
reported.
6.14.5.1
Common
Mapping
Targets
http://loinc.org
LOINC
code
for
the
element
http://snomed.info
SNOMED
CT
code
for
the
element
http://hl7.org/v3
RIM
mappin
g
http://hl7.org/v2
v2
mapping
http://nema.org/dicom
DICOM
tag
mapping
http://w3.org/vcard
vCard
equivalent
field
http://ihe.net/xds
XDS
metadata
equivalent
6.14.6
Profiled
FHIR
If
a
profile
is
unambiguous,
then
the
FHIR
profile
tooling
(ref
to
be
provided
when
the
tooling
exists)
is
able
to
generate
reference
implementation
based
object
models
that
express
the
profiled
model
natively,
where
the
object
interface
does
not
include
prohibited
elements,
treats
declared
extensions
as
primary
properties
and
slices
lists
according
to
the
profile.
This
eases
the
burden
on
an
implementer,
though
this
object
model
can
only
be
used
with
a
sub-set
of
the
possible
resources.
The
tooling
is
also
able
to
generate
bi-directional
transforms
between
the
normal
XML
format
and
an
XML
representation
of
this
profiled
object
model
and
schema
for
this
profiled
XML
representation.
This
XML
form
has
extensions
promoted
into
the
primary
XML
form
by
using
the
extension
code
as
the
XML
name
and
sliced
lists
are
renamed
to
use
the
Profile.resource.element.name
as
the
XML
element
name.
Profiles
are
only
suitable
for
this
use
if
they
ensure
that
there
are
no
clashing
extension
names
when
the
extension
definition
spaces
are
ignored
and
that
the
sliced
list
names
are
appropriate.
Implementations
are
allowed
to
exchange
this
profiled
XML
format.
Implementations
that
do
so
are
not
fully
conformant
to
FHIR;
instead
they
can
claim
to
be
conformant
to
&quot;Profiled
FHIR&quot;.
Implementations
should
consider
carefully
before
adopting
this
approach;
while
it
will
reduce
the
amount
of
work
required
to
initially
implement
particular
profiles,
it
will
increase
the
amount
of
work
required
to
exchange
this
data
with
other
communities
or
to
re-use
tooling
and
applications
that
are
also
used
in
other
contexts.
This
cost
should
particularly
be
considered
in
light
of
the
fact
that
the
previously
discussed
tooling
allows
applications
to
be
written
as
though
they
are
dealing
with
&quot;Profiled
FHIR&quot;
instances
when
they
are
in
fact
sending
and
receiving
fully
conformant
FHIR
instances.
6.14.7
Search
Parameters
Search
parameters
for
this
resource.
The
standard
parameters
also
apply.
See
Searching
for
more
information
about
searching
in
REST,
messaging,
and
services.
Name
Type
Description
Paths
_id
token
The
logical
resource
id
associated
with
the
resource
(must
be
supported
by
all
servers)
_language
token
The
language
of
the
resource
code
token
A
code
for
the
profile
in
the
format
uri::code
(server
may
choose
to
do
subsumption)
Profile.code
date
date
The
profile
publication
date
Profile.date
description
string
Text
search
in
the
description
of
the
profile
Profile.description
extension
token
An
extension
code
(use
or
definition)
Profile.extensionDefn.code
identifier
token
The
identifier
of
the
profile
Profile.identifier
name
string
Name
of
the
profile
Profile.name
publisher
string
Name
of
the
publisher
of
the
profile
Profile.publisher
status
token
The
current
status
of
the
profile
Profile.status
type
token
Type
of
resource
that
is
constrained
in
the
profile
Profile.structure.type
valueset
reference
A
vocabulary
binding
code
Profile.structure.element.definition.binding.reference[x]
(
ValueSet
)
version
token
The
version
identifier
of
the
profile
Profile.version
&copy;
HL7.org
2011+.
FHIR
DSTU
(v0.0.82.2943)
generated
on
Tue,
Sep
30,
2014
18:10+1000.
Links:
What's
a
DSTU?
|
Version
History
|
|
Propose
a
change
var
disqus_shortname
=
'fhirdstu';(function()
{var
dsq
=
document.createElement('script');
dsq.type
=
'text/javascript';
dsq.async
=
true;dsq.src
=
'//'
+
disqus_shortname
+
'.disqus.com/embed.js';(document.getElementsByTagName('head')[0]
||
document.getElementsByTagName('body')[0]).appendChild(dsq);
})();
Please
enable
JavaScript
to
view
the
comments
powered
by
Disqus.
comments
powered
by
Disqus
var
_gaq
=
_gaq
||
[];
_gaq.push(['_setAccount',
'UA-676355-1']);
_gaq.push(['_setDomainName',
'.hl7.org']);
_gaq.push(['_trackPageview']);
(function()
{
var
ga
=
document.createElement('script');
ga.type
=
'text/javascript';
ga.async
=
true;
ga.src
=
('https:'
==
document.location.protocol
?
'https://ssl'
:
'http://www')
+
'.google-analytics.com/ga.js';
var
s
=
document.getElementsByTagName('script')[0];
s.parentNode.insertBefore(ga,
s);
})();
</del>