Definition for Code SystemObligationCodes

<?xml version="1.0" encoding="UTF-8"?>

<CodeSystem xmlns="http://hl7.org/fhir">
  <id value="obligation"/> 
  <meta> 
    <lastUpdated value="2022-12-14T07:12:54.019+11:00"/> 
    <profile value="http://hl7.org/fhir/StructureDefinition/shareablecodesystem"/> 
  </meta> 
  <text> 
    <status value="generated"/> 
    <div xmlns="http://www.w3.org/1999/xhtml">
      <p> 
        <b> Properties</b> 
      </p> 
      <table class="grid">
        <tr> 
          <td> 
            <b> Code</b> 
          </td> 
          <td> 
            <b> Type</b> 
          </td> 
          <td> 
            <b> Description</b> 
          </td> 
        </tr> 
        <tr> 
          <td> qualify</td> 
          <td> boolean</td> 
          <td> Codes with this property true must have 'shall', 'should', or 'may' prepended in
             the grammar</td> 
        </tr> 
        <tr> 
          <td> combination</td> 
          <td> code</td> 
          <td> One of the codes that makes up a composite codes</td> 
        </tr> 
      </table> 
      <p> This code system 
        <code> http://hl7.org/fhir/tools/CodeSystem/obligation</code>  defines the following codes:
      </p> 
      <table class="codes">
        <tr> 
          <td> 
            <b> Lvl</b> 
          </td> 
          <td style="white-space:nowrap">
            <b> Code</b> 
          </td> 
          <td> 
            <b> Display</b> 
          </td> 
          <td> 
            <b> Definition</b> 
          </td> 
          <td> 
            <b> combination</b> 
          </td> 
        </tr> 
        <tr> 
          <td> 1</td> 
          <td style="white-space:nowrap">ModifierCodes
            <a name="obligation-ModifierCodes"> </a> 
          </td> 
          <td> ModifierCodes</td> 
          <td> SHALL/SHOULD/MAY that can be prepended to codes that have the qualify property
             = true</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  SHALL
            <a name="obligation-SHALL"> </a> 
          </td> 
          <td> SHALL</td> 
          <td> The functional requirement is mandatory. Applications that do not implement this
             functional behavior are considered non-conformant</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  SHOULD
            <a name="obligation-SHOULD"> </a> 
          </td> 
          <td> SHOULD</td> 
          <td> The functional requirement is a recommendation</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  MAY
            <a name="obligation-MAY"> </a> 
          </td> 
          <td> MAY</td> 
          <td> The functional requirement is presented as an option for applications to consider.
             Note that this is usually used to indicate a choice is still valid for an application
             to make</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 1</td> 
          <td style="white-space:nowrap">ResourceProducerObligations
            <a name="obligation-ResourceProducerObligations"> </a> 
          </td> 
          <td> ResourceProducerObligations</td> 
          <td> Resource producers are applications that assembles resources in the first place.
             Resource producers may be a server, client, sender, receiver or some middleware
             device, and they may store the resource, or merely hand it on.</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  can-send
            <a name="obligation-can-send"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY be able to correctly populate this element</td> 
          <td> Notes: Typically, this means that an application needs to demonstrate during some
             conformance testing process that there are some conditions under which it populates
             the element with a correct value</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 3</td> 
          <td style="white-space:nowrap">    will-send
            <a name="obligation-will-send"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY be capable of sending this element and,
             if the element has a value and is allowed to be shared, include it when sending
             the resource</td> 
          <td> Notes: This implementation obligation means that whenever the producer knows the
             correct value for an element, it populates it, subject to security, consent and
             privacy considerations</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  use-reason
            <a name="obligation-use-reason"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY provide an element with a DataAbsentReason
             or a NullFlavor (or equivalent) if a value is not known and the element is mandatory</td> 
          <td> Notes: When no value for an element is known, the producer populates the element
             with a [DataAbsentReason](extension-data-absent-reason.html) or a [NullFlavor](extension-iso2
            1090-nullflavor.html) (or equivalent). If no particular reason is known or reportable,
             the DataAbsentReason 'unknown' is used. Which particular extension can be used,
             see below</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  in-narrative
            <a name="obligation-in-narrative"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY ensure that this data element is represented
             in any human readable representation in a resource</td> 
          <td> Notes: When no value for an element is known, the producer populates the element
             with a [DataAbsentReason](extension-data-absent-reason.html) or a [NullFlavor](extension-iso2
            1090-nullflavor.html) (or equivalent). If no particular reason is known or reportable,
             the DataAbsentReason 'unknown' is used. Which particular extension can be used,
             see below</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  in-ui
            <a name="obligation-in-ui"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY ensure that users can enter a value for
             this element during data input</td> 
          <td> Notes: Exactly what form the input takes is not specified, but the expectation
             is that this is a value that comes from the user, and not implied internally by
             the application</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  in-store
            <a name="obligation-in-store"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY ensure that the value for this element
             is stored in a persistent data store</td> 
          <td> Notes: Exactly what the data store is not specified, nor how long it is stored
             for, but it is understand that the same value will be available in later exchanges</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  must-explain
            <a name="obligation-must-explain"> </a> 
          </td> 
          <td> Documentation applicable to Conformant Applications SHALL/SHOULD/MAY explain how
             this element is handled</td> 
          <td> Notes: this is really a rule about specifications, implying that another specification
             (which might be application documentation) either makes this element will-send,
             or explains how the use cases that involve this element do not arise, or how they
             are handled. An example: IPA marks Patient.active must-handle and must-explain.
             Client applications must process Patient.active correctly if they see it, but many
             (though *not all*) specifications and/or applications ensure that Patient.active
             will never be false, and so it will never be populated e.g. MedMij in Netherlands
             prohibits use of Patient.active, and explains that it is never false.</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 1</td> 
          <td style="white-space:nowrap">ExchangerObligations
            <a name="obligation-ExchangerObligations"> </a> 
          </td> 
          <td> ExchangerObligations</td> 
          <td> Exchangers do not produce or consume resources; they only pass the resource on.
             They may store the resource in a persistent store between reception and subsequent
             transfer. The generic FHIR servers are exchangers, as are most middleware systems.</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  preserve
            <a name="obligation-preserve"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY ensure that this element does not change
             between receiving and transfer</td> 
          <td> Notes: This does not mean that the element value cannot change, only that changing
             the element value for an element marked with this obligation moves an application
             from being an exchanger to a Consumer and a Producer, and those obligations apply</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  may-alter
            <a name="obligation-may-alter"> </a> 
          </td> 
          <td> Conformant Applications MAY choose not to alter this element value</td> 
          <td> Notes: this is the converse of preserve, and is really a null-statement - it's
             the default rule for an application. It's defined here to allow a specification
             to be explicit that it isn't conveying obligations for resource producers</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 1</td> 
          <td style="white-space:nowrap">ResourceConsumerObligations
            <a name="obligation-ResourceConsumerObligations"> </a> 
          </td> 
          <td> ResourceConsumerObligations</td> 
          <td> Resource Consumers are applications that consume resources and do something with
             them, either displaying them to humans, transferring them to some other format
             for further re-use, or using them to drive some kind of application logic process
             AKA decision support. Resource Consumers often store resources, but do not need
             to, and whether resources are stored or not between receiving them and using them
             doesn't make any difference to the obligations</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  no-error
            <a name="obligation-no-error"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY accept resources containing any valid
             value for the element without error</td> 
          <td> Notes: Applications are still able to inform the user that a value cannot be processed
             correctly, but applications aren't able to reject the information out of hand or
             ignore the element value in order to process the resource correctly (which would
             be allowed for elements that do not have this obligation). This obligation also
             applies to elements that only contain a [DataAbsentReason](extension-data-absent-reason.html)
             or a [NullFlavor](extension-iso21090-nullflavor.html) (or equivalent), should either
             of these be allowed on the consumer obligations</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  handle
            <a name="obligation-handle"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY handle the meaning of this element correctly</td> 
          <td> Notes: this rule is vague in that doesn't specify any particular handling of the
             element. But it's important because an application that ignores this element is
             non-conformant. A good example would be a status code of 'entered-in-error' - how
             exactly a Resource Consumer handles this depends on the use case etc, but the application
             can never simply ignore such a status code. Note that whether the resource or information
             from it is stored for later use is irrelevant - when the resource or information
             in it is processed, the consequences of the element are considered. That may mean
             not retaining the information for later use, or informing the user, etc. Typically,
             this obligation marks that there are known patient safety issues that can arise
             if the element is ignored. Implementers should pay particular attention to the
             possible range of values for the element from a safety perspective.</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 3</td> 
          <td style="white-space:nowrap">    display
            <a name="obligation-display"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY display the value of this element when
             presenting the data from the resource to a human user</td> 
          <td> Notes: exactly how it is displayed is not specified, but it means that a human
             looking at the content of the resource is made aware of the value of the element
             so that they can consider the meaning of the resource</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 3</td> 
          <td style="white-space:nowrap">    share
            <a name="obligation-share"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY retain the value of this element when
             the information from the resource is shared with other applications</td> 
          <td> Notes: this rule applies whether the information is being shared in the form of
             a FHIR resource, or in some other format. The rule applies whether or not the resource
             is stored prior to sharing.</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 3</td> 
          <td style="white-space:nowrap">    process
            <a name="obligation-process"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY consider the value of this element when
             processing the resource as specified by the IG</td> 
          <td> Notes: this implies that the IG that specifies this obligation provides details
             about what processing is to be performed, and the obligation specifially relates
             to the processing specified in the IG [DataAbsentReason](extension-data-absent-reason.html)
             or [NullFlavor](extension-iso21090-nullflavor.html) or equivalent when handling
             the resource or the information in it as specified by the other obligations.</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 3</td> 
          <td style="white-space:nowrap">    store
            <a name="obligation-store"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY store the value of this element in a persistent
             data store</td> 
          <td> Notes: Exactly what the data store is not specified, nor how long it is stored
             for, but it is understand that the same value will be available in later exchanges</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 3</td> 
          <td style="white-space:nowrap">    print
            <a name="obligation-print"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY print the value of this element somewhere</td> 
          <td> Notes: The form of the printing is not specified. A profile using this value SHALL
             explain the nature of the printing requirement somehow</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 3</td> 
          <td style="white-space:nowrap">    ignore
            <a name="obligation-ignore"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY ignore the value of this element somewhere</td> 
          <td> Notes: This is different to can-ignore, which indicates that the application may
             ignore it. This is an expectation that it will be ignored</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 3</td> 
          <td style="white-space:nowrap">    preserve
            <a name="obligation-preserve"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY keep the value of this element exactly</td> 
          <td> Notes: this is an expectation future references to the value, whether produced
             or consumed, will be to the exact same data. Alternative or truncated data is not
             allowed</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 3</td> 
          <td style="white-space:nowrap">    modify
            <a name="obligation-modify"> </a> 
          </td> 
          <td> Conformant Applications SHALL/SHOULD/MAY keep the value of this element exactly</td> 
          <td> Notes: this is an expectation future references to the value, whether produced
             or consumed, will be to the exact same data. Alternative or truncated data is not
             allowed</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 1</td> 
          <td style="white-space:nowrap">AggregateConcepts
            <a name="obligation-AggregateConcepts"> </a> 
          </td> 
          <td> AggregateConcepts</td> 
          <td> Predefined common combinations</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  can-populate
            <a name="obligation-can-populate"> </a> 
          </td> 
          <td> A Conformant Application MAY choose to populate this element or not</td> 
          <td> Notes: this is the converse of will-send, and is really a null-statement - it's
             the default rule for an application. It's defined here to allow a specification
             to be explicit that it isn't conveying obligations for resource producers</td> 
          <td> MAY:will-send</td> 
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  can-ignore
            <a name="obligation-can-ignore"> </a> 
          </td> 
          <td> A Conformant Application MAY ignore this element</td> 
          <td> Notes: this is the converse of must-handle, and is really a null-statement - it's
             the default rue for an application. It's defined here to allow a specification
             to be explicit that it isn't converying obligations for resource consumers</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  v2-re
            <a name="obligation-v2-re"> </a> 
          </td> 
          <td> V2 RE</td> 
          <td> RE as defined in chapter 2 of the v2 specification</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  ihe-r2
            <a name="obligation-ihe-r2"> </a> 
          </td> 
          <td> IHE R2</td> 
          <td> R2 as defined in IHE Appendix Z</td> 
          <td/>  
        </tr> 
        <tr> 
          <td> 2</td> 
          <td style="white-space:nowrap">  std
            <a name="obligation-std"> </a> 
          </td> 
          <td> Standard Obligations</td> 
          <td> The standard recommended set of obligations for IGs to use unless they know they
             want something different. Note that the standard codes don't include use-dar, use-dar-nf,
             use-dar-if-allowed / use-reason - that gets put on specific elements that justify
             this handling</td> 
          <td/>  
        </tr> 
      </table> 
    </div> 
  </text> 
  <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-wg">
    <valueCode value="fhir"/> 
  </extension> 
  <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-standards-status">
    <valueCode value="normative"/> 
  </extension> 
  <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-normative-version">
    <valueCode value="4.0.0"/> 
  </extension> 
  <extension url="http://hl7.org/fhir/StructureDefinition/structuredefinition-fmm">
    <valueInteger value="5"/> 
  </extension> 
  <url value="http://hl7.org/fhir/tools/CodeSystem/obligation"/> 
  <version value="5.0.0-snapshot3"/> 
  <name value="ObligationCodes"/> 
  <title value="Obligation Codes"/> 
  <status value="active"/> 
  <experimental value="false"/> 
  <description value="Codes that describe application obligations for handling FHIR content. There are
   three kinds of codes in this code system:
 * Qualifier codes: SHALL/SHOULD/MAY
 * Functional codes - these describe a functional behavior applications may implement,
   and have the concept property qualify = true, and must be qualified by one of SHALL,
   SHOULD, or MAY
 * Composite codes - these specialise AggregateConcepts, and have an concept property
   'expression' that defines them in terms of a set of functional codes
 
 Functional and Qualifier codes are combined using the syntax ```[modifierCode]
   &quot;:&quot; [obligationCode]``` e.g. SHALL:will-send
 
 The functional codes are grouped into three different high level categories:
 * ResourceProducerObligations - functions that pertain to applications that produce
   resources (typically from databases or forms)
 * ExchangerObligations - functions that pertain to applications that transfer
   resources between other applications (including FHIR repositories)
 * ResourceConsumerObligations - functions that pertain to applications that consume
   the content of resources and do something with them
 
 Note that applications typically produce and consume resources, whether client,
   server or something else again, and 
 many applications transfer resources as well
 "/> 
  <jurisdiction> 
    <coding> 
      <system value="http://unstats.un.org/unsd/methods/m49/m49.htm"/> 
      <code value="001"/> 
    </coding> 
  </jurisdiction> 
  <caseSensitive value="true"/> 
  <valueSet value="http://hl7.org/fhir/ValueSet/obligation"/> 
  <hierarchyMeaning value="is-a"/> 
  <compositional value="true"/> 
  <content value="complete"/> 
  <property> 
    <code value="qualify"/> 
    <description value="Codes with this property true must have 'shall', 'should', or 'may' prepended in
     the grammar"/> 
    <type value="boolean"/> 
  </property> 
  <property> 
    <code value="combination"/> 
    <description value="One of the codes that makes up a composite codes"/> 
    <type value="code"/> 
  </property> 
  <concept> 
    <code value="ModifierCodes"/> 
    <display value="ModifierCodes"/> 
    <definition value="SHALL/SHOULD/MAY that can be prepended to codes that have the qualify property
     = true"/> 
    <concept> 
      <code value="SHALL"/> 
      <display value="SHALL"/> 
      <definition value="The functional requirement is mandatory. Applications that do not implement this
       functional behavior are considered non-conformant"/> 
    </concept> 
    <concept> 
      <code value="SHOULD"/> 
      <display value="SHOULD"/> 
      <definition value="The functional requirement is a recommendation"/> 
    </concept> 
    <concept> 
      <code value="MAY"/> 
      <display value="MAY"/> 
      <definition value="The functional requirement is presented as an option for applications to consider.
       Note that this is usually used to indicate a choice is still valid for an application
       to make"/> 
    </concept> 
  </concept> 
  <concept> 
    <code value="ResourceProducerObligations"/> 
    <display value="ResourceProducerObligations"/> 
    <definition value="Resource producers are applications that assembles resources in the first place.
     Resource producers may be a server, client, sender, receiver or some middleware
     device, and they may store the resource, or merely hand it on."/> 
    <concept> 
      <code value="can-send"/> 
      <display value="Conformant Applications SHALL/SHOULD/MAY be able to correctly populate this element"/> 
      <definition value="Notes: Typically, this means that an application needs to demonstrate during some
       conformance testing process that there are some conditions under which it populates
       the element with a correct value"/> 
      <property> 
        <code value="shall-should-may"/> 
        <valueBoolean value="true"/> 
      </property> 
      <concept> 
        <code value="will-send"/> 
        <display value="Conformant Applications SHALL/SHOULD/MAY be capable of sending this element and,
         if the element has a value and is allowed to be shared, include it when sending
         the resource"/> 
        <definition value="Notes: This implementation obligation means that whenever the producer knows the
         correct value for an element, it populates it, subject to security, consent and
         privacy considerations"/> 
        <property> 
          <code value="shall-should-may"/> 
          <valueBoolean value="true"/> 
        </property> 
      </concept> 
    </concept> 
    <concept> 
      <code value="use-reason"/> 
      <display value="Conformant Applications SHALL/SHOULD/MAY provide an element with a DataAbsentReason
       or a NullFlavor (or equivalent) if a value is not known and the element is mandatory"/> 
      <definition value="Notes: When no value for an element is known, the producer populates the element
       with a [DataAbsentReason](extension-data-absent-reason.html) or a [NullFlavor](extension-iso2
      1090-nullflavor.html) (or equivalent). If no particular reason is known or reportable,
       the DataAbsentReason 'unknown' is used. Which particular extension can be used,
       see below"/> 
      <property> 
        <code value="shall-should-may"/> 
        <valueBoolean value="true"/> 
      </property> 
    </concept> 
    <concept> 
      <code value="in-narrative"/> 
      <display value="Conformant Applications SHALL/SHOULD/MAY ensure that this data element is represented
       in any human readable representation in a resource"/> 
      <definition value="Notes: When no value for an element is known, the producer populates the element
       with a [DataAbsentReason](extension-data-absent-reason.html) or a [NullFlavor](extension-iso2
      1090-nullflavor.html) (or equivalent). If no particular reason is known or reportable,
       the DataAbsentReason 'unknown' is used. Which particular extension can be used,
       see below"/> 
      <property> 
        <code value="shall-should-may"/> 
        <valueBoolean value="true"/> 
      </property> 
    </concept> 
    <concept> 
      <code value="in-ui"/> 
      <display value="Conformant Applications SHALL/SHOULD/MAY ensure that users can enter a value for
       this element during data input"/> 
      <definition value="Notes: Exactly what form the input takes is not specified, but the expectation
       is that this is a value that comes from the user, and not implied internally by
       the application"/> 
      <property> 
        <code value="shall-should-may"/> 
        <valueBoolean value="true"/> 
      </property> 
    </concept> 
    <concept> 
      <code value="in-store"/> 
      <display value="Conformant Applications SHALL/SHOULD/MAY ensure that the value for this element
       is stored in a persistent data store"/> 
      <definition value="Notes: Exactly what the data store is not specified, nor how long it is stored
       for, but it is understand that the same value will be available in later exchanges"/> 
      <property> 
        <code value="shall-should-may"/> 
        <valueBoolean value="true"/> 
      </property> 
    </concept> 
    <concept> 
      <code value="must-explain"/> 
      <display value="Documentation applicable to Conformant Applications SHALL/SHOULD/MAY explain how
       this element is handled"/> 
      <definition value="Notes: this is really a rule about specifications, implying that another specification
       (which might be application documentation) either makes this element will-send,
       or explains how the use cases that involve this element do not arise, or how they
       are handled. An example: IPA marks Patient.active must-handle and must-explain.
       Client applications must process Patient.active correctly if they see it, but many
       (though *not all*) specifications and/or applications ensure that Patient.active
       will never be false, and so it will never be populated e.g. MedMij in Netherlands
       prohibits use of Patient.active, and explains that it is never false."/> 
      <property> 
        <code value="shall-should-may"/> 
        <valueBoolean value="true"/> 
      </property> 
    </concept> 
  </concept> 
  <concept> 
    <code value="ExchangerObligations"/> 
    <display value="ExchangerObligations"/> 
    <definition value="Exchangers do not produce or consume resources; they only pass the resource on.
     They may store the resource in a persistent store between reception and subsequent
     transfer. The generic FHIR servers are exchangers, as are most middleware systems."/> 
    <concept> 
      <code value="preserve"/> 
      <display value="Conformant Applications SHALL/SHOULD/MAY ensure that this element does not change
       between receiving and transfer"/> 
      <definition value="Notes: This does not mean that the element value cannot change, only that changing
       the element value for an element marked with this obligation moves an application
       from being an exchanger to a Consumer and a Producer, and those obligations apply"/> 
      <property> 
        <code value="shall-should-may"/> 
        <valueBoolean value="true"/> 
      </property> 
    </concept> 
    <concept> 
      <code value="may-alter"/> 
      <display value="Conformant Applications MAY choose not to alter this element value"/> 
      <definition value="Notes: this is the converse of preserve, and is really a null-statement - it's
       the default rule for an application. It's defined here to allow a specification
       to be explicit that it isn't conveying obligations for resource producers"/> 
    </concept> 
  </concept> 
  <concept> 
    <code value="ResourceConsumerObligations"/> 
    <display value="ResourceConsumerObligations"/> 
    <definition value="Resource Consumers are applications that consume resources and do something with
     them, either displaying them to humans, transferring them to some other format
     for further re-use, or using them to drive some kind of application logic process
     AKA decision support. Resource Consumers often store resources, but do not need
     to, and whether resources are stored or not between receiving them and using them
     doesn't make any difference to the obligations"/> 
    <concept> 
      <code value="no-error"/> 
      <display value="Conformant Applications SHALL/SHOULD/MAY accept resources containing any valid
       value for the element without error"/> 
      <definition value="Notes: Applications are still able to inform the user that a value cannot be processed
       correctly, but applications aren't able to reject the information out of hand or
       ignore the element value in order to process the resource correctly (which would
       be allowed for elements that do not have this obligation). This obligation also
       applies to elements that only contain a [DataAbsentReason](extension-data-absent-reason.html)
       or a [NullFlavor](extension-iso21090-nullflavor.html) (or equivalent), should either
       of these be allowed on the consumer obligations"/> 
      <property> 
        <code value="shall-should-may"/> 
        <valueBoolean value="true"/> 
      </property> 
    </concept> 
    <concept> 
      <code value="handle"/> 
      <display value="Conformant Applications SHALL/SHOULD/MAY handle the meaning of this element correctly"/> 
      <definition value="Notes: this rule is vague in that doesn't specify any particular handling of the
       element. But it's important because an application that ignores this element is
       non-conformant. A good example would be a status code of 'entered-in-error' - how
       exactly a Resource Consumer handles this depends on the use case etc, but the application
       can never simply ignore such a status code. Note that whether the resource or information
       from it is stored for later use is irrelevant - when the resource or information
       in it is processed, the consequences of the element are considered. That may mean
       not retaining the information for later use, or informing the user, etc. Typically,
       this obligation marks that there are known patient safety issues that can arise
       if the element is ignored. Implementers should pay particular attention to the
       possible range of values for the element from a safety perspective."/> 
      <property> 
        <code value="shall-should-may"/> 
        <valueBoolean value="true"/> 
      </property> 
      <concept> 
        <code value="display"/> 
        <display value="Conformant Applications SHALL/SHOULD/MAY display the value of this element when
         presenting the data from the resource to a human user"/> 
        <definition value="Notes: exactly how it is displayed is not specified, but it means that a human
         looking at the content of the resource is made aware of the value of the element
         so that they can consider the meaning of the resource"/> 
        <property> 
          <code value="shall-should-may"/> 
          <valueBoolean value="true"/> 
        </property> 
      </concept> 
      <concept> 
        <code value="share"/> 
        <display value="Conformant Applications SHALL/SHOULD/MAY retain the value of this element when
         the information from the resource is shared with other applications"/> 
        <definition value="Notes: this rule applies whether the information is being shared in the form of
         a FHIR resource, or in some other format. The rule applies whether or not the resource
         is stored prior to sharing."/> 
        <property> 
          <code value="shall-should-may"/> 
          <valueBoolean value="true"/> 
        </property> 
      </concept> 
      <concept> 
        <code value="process"/> 
        <display value="Conformant Applications SHALL/SHOULD/MAY consider the value of this element when
         processing the resource as specified by the IG"/> 
        <definition value="Notes: this implies that the IG that specifies this obligation provides details
         about what processing is to be performed, and the obligation specifially relates
         to the processing specified in the IG [DataAbsentReason](extension-data-absent-reason.html)
         or [NullFlavor](extension-iso21090-nullflavor.html) or equivalent when handling
         the resource or the information in it as specified by the other obligations."/> 
        <property> 
          <code value="shall-should-may"/> 
          <valueBoolean value="true"/> 
        </property> 
      </concept> 
      <concept> 
        <code value="store"/> 
        <display value="Conformant Applications SHALL/SHOULD/MAY store the value of this element in a persistent
         data store"/> 
        <definition value="Notes: Exactly what the data store is not specified, nor how long it is stored
         for, but it is understand that the same value will be available in later exchanges"/> 
        <property> 
          <code value="shall-should-may"/> 
          <valueBoolean value="true"/> 
        </property> 
      </concept> 
      <concept> 
        <code value="print"/> 
        <display value="Conformant Applications SHALL/SHOULD/MAY print the value of this element somewhere"/> 
        <definition value="Notes: The form of the printing is not specified. A profile using this value SHALL
         explain the nature of the printing requirement somehow"/> 
        <property> 
          <code value="shall-should-may"/> 
          <valueBoolean value="true"/> 
        </property> 
      </concept> 
      <concept> 
        <code value="ignore"/> 
        <display value="Conformant Applications SHALL/SHOULD/MAY ignore the value of this element somewhere"/> 
        <definition value="Notes: This is different to can-ignore, which indicates that the application may
         ignore it. This is an expectation that it will be ignored"/> 
        <property> 
          <code value="shall-should-may"/> 
          <valueBoolean value="true"/> 
        </property> 
      </concept> 
      <concept> 
        <code value="preserve"/> 
        <display value="Conformant Applications SHALL/SHOULD/MAY keep the value of this element exactly"/> 
        <definition value="Notes: this is an expectation future references to the value, whether produced
         or consumed, will be to the exact same data. Alternative or truncated data is not
         allowed"/> 
        <property> 
          <code value="shall-should-may"/> 
          <valueBoolean value="true"/> 
        </property> 
      </concept> 
      <concept> 
        <code value="modify"/> 
        <display value="Conformant Applications SHALL/SHOULD/MAY keep the value of this element exactly"/> 
        <definition value="Notes: this is an expectation future references to the value, whether produced
         or consumed, will be to the exact same data. Alternative or truncated data is not
         allowed"/> 
        <property> 
          <code value="shall-should-may"/> 
          <valueBoolean value="true"/> 
        </property> 
      </concept> 
    </concept> 
  </concept> 
  <concept> 
    <code value="AggregateConcepts"/> 
    <display value="AggregateConcepts"/> 
    <definition value="Predefined common combinations"/> 
    <concept> 
      <code value="can-populate"/> 
      <display value="A Conformant Application MAY choose to populate this element or not"/> 
      <definition value="Notes: this is the converse of will-send, and is really a null-statement - it's
       the default rule for an application. It's defined here to allow a specification
       to be explicit that it isn't conveying obligations for resource producers"/> 
      <property> 
        <code value="combination"/> 
        <valueCode value="MAY:will-send"/> 
      </property> 
    </concept> 
    <concept> 
      <code value="can-ignore"/> 
      <display value="A Conformant Application MAY ignore this element"/> 
      <definition value="Notes: this is the converse of must-handle, and is really a null-statement - it's
       the default rue for an application. It's defined here to allow a specification
       to be explicit that it isn't converying obligations for resource consumers"/> 
      <property> 
        <code value="component"/> 
        <valueCode value="MAY:ignore"/> 
      </property> 
    </concept> 
    <concept> 
      <code value="v2-re"/> 
      <display value="V2 RE"/> 
      <definition value="RE as defined in chapter 2 of the v2 specification"/> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:can-send"/> 
      </property> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:use-dar-nf"/> 
      </property> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:must-handle"/> 
      </property> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:must-display"/> 
      </property> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHOULD:must-share"/> 
      </property> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:no-error"/> 
      </property> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:assume-unknown"/> 
      </property> 
    </concept> 
    <concept> 
      <code value="ihe-r2"/> 
      <display value="IHE R2"/> 
      <definition value="R2 as defined in IHE Appendix Z"/> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:will-send"/> 
      </property> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:can-ignore"/> 
      </property> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:no-error"/> 
      </property> 
    </concept> 
    <concept> 
      <code value="std"/> 
      <display value="Standard Obligations"/> 
      <definition value="The standard recommended set of obligations for IGs to use unless they know they
       want something different. Note that the standard codes don't include use-dar, use-dar-nf,
       use-dar-if-allowed / use-reason - that gets put on specific elements that justify
       this handling"/> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:will-send"/> 
      </property> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:will-present"/> 
      </property> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHALL:no-error"/> 
      </property> 
      <property> 
        <code value="component"/> 
        <valueCode value="SHOULD:must-handle"/> 
      </property> 
    </concept> 
  </concept> 
</CodeSystem>