Copy of 'RDC HDS STU3'

CareplanTimeblockOptions

This extension is used in the Bolus-CarePlan to capture the device settings for timeblocks. The Bolus Advice is based on the device settings for Bolus Advice options, consisting of three blocks: advice options, health events and timeblocks.

The scope of this extension is ACSPIX BG file.

With timeblocks patients can define specific parts of the day and adapt settings like bloodglucose target levels, carb ratio's and insuline sensitivity accordingly. The following attributes are defined:

Parameter	Description	format
StartTime	Start time of this timeblock	format hh:mm
EndTime	End time of this timeblock (the last minute in this timeblock)	hh:mm
LowerLimit*	Lower Bg limit	mg/dL or mmol/l
UpperLimit	Upper Bg limit	mg/dL or mmol/l
CarbRatioInsulin	Carb ratio insulin value	units: #0.0
CarbRatioCarb**	Carb ratio carb value	g
InsulinSensitivityInsulin	Insulin sensitivity insulin value	units: #0.0
InsulinSensitivityBG**	Insulin sensitivity BG value	mg/dL or mmol/L

*All profiles are constrained to mg/dL. Implementers are responsible for transforming the values.

**These attributes are only present if set by the user in the meter

An example of the XML code is given below:

<TIMEBLOCKS>
    <TIMEBLOCK StartTime="07:00" EndTime="10:59"
        LowerLimit="80" UpperLimit="130"
        CarbRatioInsulin="1.3" CarbRatioCarb="40"
        InsulinSensitivityInsulin="1.3" InsulinSensitivityBG="10" />
    <TIMEBLOCK StartTime="11:00" EndTime="23:59"
        LowerLimit="70" UpperLimit="130"
        CarbRatioInsulin="2.5" InsulinSensitivityInsulin="1.8" />
</TIMEBLOCKS>

The FHIR output of the first extension repetition:

"extension": [
        {
         "extension": [
            {
               "url": "timeblock",
               "valueTiming": 
                {
                    "repeat":
                        {
                                "timeOfDay": "07:00:00",
                                "duration": "240",
                                "durationUnit": "min",
                                "frequency": 1
                            }                        
                    }
            },
            {
               "url": "LowerLimit",
               "valueQuantity": 
                    {
                        "value": "70",
                        "unit": "mg/dL",
                        "system": "https://unitsofmeasure.org",
                        "code": "mg/dL"
                    }
            },
            {
               "url": "UpperLimit",
               "valueQuantity": 
                    {
                        "value": "130",
                        "unit": "mg/dL",
                        "system": "https://unitsofmeasure.org",
                        "code": "mg/dL"
                    }
            },
            {
               "url": "CarbRatioInsulin",
               "valueQuantity": 
                    {
                        "value": "1.3",
                        "unit": "[iU]",
                        "system": "https://roche.com/fhir/rdc/cs",
                        "code": "[iU]"
                    }
            },
            {
               "url": "CarbRatioCarb",
               "valueQuantity": 
                    {
                        "value": "40",
                        "unit": "g",
                        "system": "https://unitsofmeasure.org",
                        "code": "g"
                    }
            },
            {
               "url": "InsulinSensitivityInsulin",
               "valueQuantity": 
                    {
                        "value": "1.3",
                        "unit": "[iU]",
                        "system": "https://roche.com/fhir/rdc/cs",
                        "code": "[iU]"
                    }
            },
            {
               "url": "InsulinSensitivityBG",
               "valueQuantity": 
                    {
                        "value": "10",
                        "unit": "mg/dL",
                        "system": "https://unitsofmeasure.org",
                        "code": "mg/dL"
                    }
            }
         ],
         "url": "http://roche.com/fhir/StructureDefinition/careplan-timeblock-options"
      }
    ]

Overview

The below overview shows the elements of the resource, data type and the cardinality of each. Further details like "Binding"/"Fixed values"/"contraints" etc can be found on clicking on each element.

Canonical URL - http://roche.com/fhir/rdc/StructureDefinition/careplan-timeblock-options

careplan-timeblock-options (Extension)	C		Extension	There are no (further) constraints on this element Element id Extension Short description Optional Extensions Element Definition Optional Extension Element - found in all resources. Data type Extension Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	Element id Extension.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
timeblock	C	0..1	Extension	There are no (further) constraints on this element Element id Extension.extension:timeblock Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:timeblock.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:timeblock.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
url		1..1	uriFixed Value	Element id Extension.extension:timeblock.url Short description identifies the meaning of the extension Definition Source of the definition for the extension code - a logical name or a URL. Comments The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension. Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value timeblock Mappings rim: n/a rim: N/A
valueTiming		0..1	Timing	Element id Extension.extension:timeblock.value[x]:valueTiming Short description Value of extension Definition Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list). Data type Timing Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
event	Σ	0..*	dateTime	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.event Short description When the event occurs Definition Identifies specific times when the event occurs. Requirements In an MAR, for instance, you need to take a general specification, and turn it into a precise specification. Data type dateTime Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: QLIST<TS>
repeat	Σ C	0..1	Element	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat Short description When the event is to occur Definition A set of rules that describe when the event is scheduled. Requirements Many timing schedules are determined by regular repetitions. Data type Element Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` tim-9: If there's an offset, there must be a when (and not C, CM, CD, CV) `offset.empty() or (when.exists() and ((when in ('C' \| 'CM' \| 'CD' \| 'CV')).not()))` tim-5: period SHALL be a non-negative value `period.exists() implies period >= 0` tim-6: If there's a periodMax, there must be a period `periodMax.empty() or period.exists()` tim-7: If there's a durationMax, there must be a duration `durationMax.empty() or duration.exists()` tim-8: If there's a countMax, there must be a count `countMax.empty() or count.exists()` tim-1: if there's a duration, there needs to be duration units `duration.empty() or durationUnit.exists()` tim-10: If there's a timeOfDay, there cannot be be a when, or vice versa `timeOfDay.empty() or when.empty()` tim-2: if there's a period, there needs to be period units `period.empty() or periodUnit.exists()` tim-4: duration SHALL be a non-negative value `duration.exists() implies duration >= 0` Mappings rim: n/a rim: Implies PIVL or EIVL
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
bounds[x]	Σ	0..1		There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.bounds[x] Short description Length/Range of lengths, or (Start and/or end) limits Definition Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule. Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: IVL(TS) used in a QSI
boundsDuration			Duration	There are no (further) constraints on this element Data type Duration
boundsPeriod			Period	There are no (further) constraints on this element Data type Period
boundsRange			Range	There are no (further) constraints on this element Data type Range
count	Σ	0..1	integer	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.count Short description Number of times to repeat Definition A total count of the desired number of repetitions. Requirements Repetitions may be limited by end time or total occurrences. Comments If you have both bounds and count, then this should be understood as within the bounds period, until count times happens. Data type integer Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: PIVL.count
countMax	Σ	0..1	integer	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.countMax Short description Maximum number of times to repeat Definition A maximum value for the count of the desired repetitions (e.g. do something 6-8 times). Comments 32 bit number; for values larger than this, use decimal Data type integer Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: PIVL.count
duration	Σ	0..1	decimal	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.duration Short description How long when it happens Definition How long this thing happens for when it happens. Requirements Some activities are not instantaneous and need to be maintained for a period of time. Comments For some events the duration is part of the definition of the event (e.g. IV infusions, where the duration is implicit in the specified quantity and rate). For others, it's part of the timing specification (e.g. exercise). Data type decimal Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: PIVL.phase
durationMax	Σ	0..1	decimal	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.durationMax Short description How long when it happens (Max) Definition The upper limit of how long this thing happens for when it happens. Requirements Some activities are not instantaneous and need to be maintained for a period of time. Comments For some events the duration is part of the definition of the event (e.g. IV infusions, where the duration is implicit in the specified quantity and rate). For others, it's part of the timing specification (e.g. exercise). Data type decimal Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: PIVL.phase
durationUnit	Σ	0..1	codeBinding	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.durationUnit Short description s \| min \| h \| d \| wk \| mo \| a - unit of time (UCUM) Definition The units of time for the duration, in UCUM units. Comments Note that FHIR strings may not exceed 1MB in size Data type code Binding A unit of time (units from UCUM). UnitsOfTime (required) Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: PIVL.phase.unit
frequency	Σ	0..1	integer	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.frequency Short description Event occurs frequency times per period Definition The number of times to repeat the action within the specified period / period range (i.e. both period and periodMax provided). Comments 32 bit number; for values larger than this, use decimal Data type integer Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Default value 1 Mappings rim: n/a rim: PIVL.phase
frequencyMax	Σ	0..1	integer	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.frequencyMax Short description Event occurs up to frequencyMax times per period Definition If present, indicates that the frequency is a range - so to repeat between [frequency] and [frequencyMax] times within the period or period range. Comments 32 bit number; for values larger than this, use decimal Data type integer Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: PIVL.phase
period	Σ	0..1	decimal	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.period Short description Event occurs frequency times per period Definition Indicates the duration of time over which repetitions are to occur; e.g. to express "3 times per day", 3 would be the frequency and "1 day" would be the period. Comments Do not use a IEEE type floating point type, instead use something that works like a true decimal, with inbuilt precision (e.g. Java BigInteger) Data type decimal Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: PIVL.phase
periodMax	Σ	0..1	decimal	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.periodMax Short description Upper limit of period (3-4 hours) Definition If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as "do this once every 3-5 days. Comments Do not use a IEEE type floating point type, instead use something that works like a true decimal, with inbuilt precision (e.g. Java BigInteger) Data type decimal Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: PIVL.phase
periodUnit	Σ	0..1	codeBinding	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.periodUnit Short description s \| min \| h \| d \| wk \| mo \| a - unit of time (UCUM) Definition The units of time for the period in UCUM units. Comments Note that FHIR strings may not exceed 1MB in size Data type code Binding A unit of time (units from UCUM). UnitsOfTime (required) Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: PIVL.phase.unit
dayOfWeek	Σ	0..*	codeBinding	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.dayOfWeek Short description mon \| tue \| wed \| thu \| fri \| sat \| sun Definition If one or more days of week is provided, then the action happens only on the specified day(s). Comments If no days are specified, the action is assumed to happen every day as otherwise specified. The elements frequency and period cannot be used as well as dayOfWeek. Data type code Binding DaysOfWeek (required) Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
timeOfDay	Σ	0..*	time	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.timeOfDay Short description Time of day for action Definition Specified time of day for action to take place. Comments When time of day is specified, it is inferred that the action happens every day (as filtered by dayofWeek) on the specified times. The elements when, frequency and period cannot be used as well as timeOfDay. Data type time Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
when	Σ	0..*	codeBinding	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.when Short description Regular life events the event is tied to Definition Real world events that the occurrence of the event should be tied to. Requirements Timings are frequently determined by occurrences such as waking, eating and sleep. Comments When more than one event is listed, the event is tied to the union of the specified events. Data type code Binding Real world event relating to the schedule. EventTiming (required) Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: EIVL.event
offset	Σ	0..1	unsignedInt	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.repeat.offset Short description Minutes from event (before or after) Definition The number of minutes from the event. If the event code does not indicate whether the minutes is before or after the event, then the offset is assumed to be after the event. Comments 32 bit number; for values larger than this, use decimal Data type unsignedInt Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: EIVL.offset
code	Σ	0..1	CodeableConceptBinding	There are no (further) constraints on this element Element id Extension.extension:timeblock.value[x]:valueTiming.code Short description BID \| TID \| QID \| AM \| PM \| QD \| QOD \| Q4H \| Q6H + Definition A code for the timing schedule. Some codes such as BID are ubiquitous, but many institutions define their own additional codes. If a code is provided, the code is understood to be a complete statement of whatever is specified in the structured timing data, and either the code or the data may be used to interpret the Timing, with the exception that .repeat.bounds still applies over the code (and is not contained in the code). Comments BID etc are defined as 'at institutionally specified times'. For example, an institution may choose that BID is "always at 7am and 6pm". If it is inappropriate for this choice to be made, the code BID should not be used. Instead, a distinct organization-specific code should be used in place of the HL7-defined BID code and/or the a structured representation should be used (in this case, specifying the two event times). Data type CodeableConcept Binding Code for a known / defined timing pattern. TimingAbbreviation (preferred) Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: CE/CNE/CWE rim: CD orim: fhir:CodeableConcept rdfs:subClassOf dt:CD rim: QSC.code
LowerLimit	C	0..1	Extension	There are no (further) constraints on this element Element id Extension.extension:LowerLimit Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:LowerLimit.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:LowerLimit.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
url		1..1	uriFixed Value	Element id Extension.extension:LowerLimit.url Short description identifies the meaning of the extension Definition Source of the definition for the extension code - a logical name or a URL. Comments The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension. Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value LowerLimit Mappings rim: n/a rim: N/A
valueQuantity		0..1	Quantity	Element id Extension.extension:LowerLimit.value[x]:valueQuantity Short description Value of extension Definition Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list). Data type Quantity Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: N/A
UpperLimit	C	0..1	Extension	There are no (further) constraints on this element Element id Extension.extension:UpperLimit Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:UpperLimit.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:UpperLimit.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
url		1..1	uriFixed Value	Element id Extension.extension:UpperLimit.url Short description identifies the meaning of the extension Definition Source of the definition for the extension code - a logical name or a URL. Comments The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension. Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value UpperLimit Mappings rim: n/a rim: N/A
valueQuantity		0..1	Quantity	Element id Extension.extension:UpperLimit.value[x]:valueQuantity Short description Value of extension Definition Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list). Data type Quantity Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: N/A
CarbRatioInsulin	C	0..1	Extension	There are no (further) constraints on this element Element id Extension.extension:CarbRatioInsulin Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:CarbRatioInsulin.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:CarbRatioInsulin.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
url		1..1	uriFixed Value	Element id Extension.extension:CarbRatioInsulin.url Short description identifies the meaning of the extension Definition Source of the definition for the extension code - a logical name or a URL. Comments The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension. Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value CarbRatioInsulin Mappings rim: n/a rim: N/A
valueQuantity		0..1	Quantity	Element id Extension.extension:CarbRatioInsulin.value[x]:valueQuantity Short description Value of extension Definition Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list). Data type Quantity Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
value	Σ	0..1	decimal	There are no (further) constraints on this element Element id Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.value Short description Numerical value (with implicit precision) Definition The value of the measured amount. The value includes an implicit precision in the presentation of the value. Requirements Precision is handled implicitly in almost all cases of measurement. Comments The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books). Data type decimal Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: SN.2 / CQ - N/A rim: PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value
comparator	Σ ?!	0..1	codeBinding	There are no (further) constraints on this element Element id Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.comparator Short description < \| <= \| >= \| > - how to understand the value Definition How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value. Requirements Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology. Comments This is labeled as "Is Modifier" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value. Meaning when missing If there is no comparator, then there is no modification of the value Data type code Binding How the Quantity should be understood and represented. QuantityComparator (required) Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: SN.1 / CQ.1 rim: IVL properties
unit	Σ	0..1	stringFixed Value	Element id Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.unit Short description Unit representation Definition A human-readable form of the unit. Requirements There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value [iU] Mappings rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.unit
system	Σ C	0..1	uri	There are no (further) constraints on this element Element id Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.system Short description System that defines coded unit form Definition The identification of the system that provides the coded form of the unit. Requirements Need to know the system that defines the coded form of the unit. Comments see http://en.wikipedia.org/wiki/Uniform_resource_identifier Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1, qty-3 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: CO.codeSystem, PQ.translation.codeSystem
code	Σ	0..1	code	There are no (further) constraints on this element Element id Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.code Short description Coded form of the unit Definition A computer processable form of the unit in some unit representation system. Requirements Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest. Comments The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency. The context of use may additionally require a code from a particular system. Data type code Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.code, MO.currency, PQ.translation.code
CarbRatioCarb	C	0..1	Extension	There are no (further) constraints on this element Element id Extension.extension:CarbRatioCarb Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:CarbRatioCarb.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:CarbRatioCarb.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
url		1..1	uriFixed Value	Element id Extension.extension:CarbRatioCarb.url Short description identifies the meaning of the extension Definition Source of the definition for the extension code - a logical name or a URL. Comments The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension. Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value CarbRatioCarb Mappings rim: n/a rim: N/A
valueQuantity		0..1	Quantity	Element id Extension.extension:CarbRatioCarb.value[x]:valueQuantity Short description Value of extension Definition Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list). Data type Quantity Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:CarbRatioCarb.value[x]:valueQuantity.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:CarbRatioCarb.value[x]:valueQuantity.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
value	Σ	0..1	decimal	There are no (further) constraints on this element Element id Extension.extension:CarbRatioCarb.value[x]:valueQuantity.value Short description Numerical value (with implicit precision) Definition The value of the measured amount. The value includes an implicit precision in the presentation of the value. Requirements Precision is handled implicitly in almost all cases of measurement. Comments The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books). Data type decimal Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: SN.2 / CQ - N/A rim: PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value
comparator	Σ ?!	0..1	codeBinding	There are no (further) constraints on this element Element id Extension.extension:CarbRatioCarb.value[x]:valueQuantity.comparator Short description < \| <= \| >= \| > - how to understand the value Definition How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value. Requirements Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology. Comments This is labeled as "Is Modifier" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value. Meaning when missing If there is no comparator, then there is no modification of the value Data type code Binding How the Quantity should be understood and represented. QuantityComparator (required) Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: SN.1 / CQ.1 rim: IVL properties
unit	Σ	0..1	stringFixed Value	Element id Extension.extension:CarbRatioCarb.value[x]:valueQuantity.unit Short description Unit representation Definition A human-readable form of the unit. Requirements There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value g Mappings rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.unit
system	Σ C	0..1	uri	There are no (further) constraints on this element Element id Extension.extension:CarbRatioCarb.value[x]:valueQuantity.system Short description System that defines coded unit form Definition The identification of the system that provides the coded form of the unit. Requirements Need to know the system that defines the coded form of the unit. Comments see http://en.wikipedia.org/wiki/Uniform_resource_identifier Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1, qty-3 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: CO.codeSystem, PQ.translation.codeSystem
code	Σ	0..1	code	There are no (further) constraints on this element Element id Extension.extension:CarbRatioCarb.value[x]:valueQuantity.code Short description Coded form of the unit Definition A computer processable form of the unit in some unit representation system. Requirements Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest. Comments The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency. The context of use may additionally require a code from a particular system. Data type code Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.code, MO.currency, PQ.translation.code
InsulinSensitivityInsulin	C	0..1	Extension	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityInsulin Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityInsulin.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityInsulin.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
url		1..1	uriFixed Value	Element id Extension.extension:InsulinSensitivityInsulin.url Short description identifies the meaning of the extension Definition Source of the definition for the extension code - a logical name or a URL. Comments The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension. Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value InsulinSensitivityInsulin Mappings rim: n/a rim: N/A
valueQuantity		0..1	Quantity	Element id Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity Short description Value of extension Definition Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list). Data type Quantity Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
value	Σ	0..1	decimal	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.value Short description Numerical value (with implicit precision) Definition The value of the measured amount. The value includes an implicit precision in the presentation of the value. Requirements Precision is handled implicitly in almost all cases of measurement. Comments The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books). Data type decimal Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: SN.2 / CQ - N/A rim: PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value
comparator	Σ ?!	0..1	codeBinding	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.comparator Short description < \| <= \| >= \| > - how to understand the value Definition How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value. Requirements Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology. Comments This is labeled as "Is Modifier" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value. Meaning when missing If there is no comparator, then there is no modification of the value Data type code Binding How the Quantity should be understood and represented. QuantityComparator (required) Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: SN.1 / CQ.1 rim: IVL properties
unit	Σ	0..1	stringFixed Value	Element id Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.unit Short description Unit representation Definition A human-readable form of the unit. Requirements There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value [iU] Mappings rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.unit
system	Σ C	0..1	uri	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.system Short description System that defines coded unit form Definition The identification of the system that provides the coded form of the unit. Requirements Need to know the system that defines the coded form of the unit. Comments see http://en.wikipedia.org/wiki/Uniform_resource_identifier Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1, qty-3 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: CO.codeSystem, PQ.translation.codeSystem
code	Σ	0..1	code	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.code Short description Coded form of the unit Definition A computer processable form of the unit in some unit representation system. Requirements Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest. Comments The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency. The context of use may additionally require a code from a particular system. Data type code Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.code, MO.currency, PQ.translation.code
InsulinSensitivityBG	C	0..1	Extension	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityBG Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityBG.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:InsulinSensitivityBG.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
url		1..1	uriFixed Value	Element id Extension.extension:InsulinSensitivityBG.url Short description identifies the meaning of the extension Definition Source of the definition for the extension code - a logical name or a URL. Comments The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension. Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value InsulinSensitivityBG Mappings rim: n/a rim: N/A
valueQuantity		0..1	Quantity	Element id Extension.extension:InsulinSensitivityBG.value[x]:valueQuantity Short description Value of extension Definition Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list). Data type Quantity Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: N/A
startTime	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:startTime Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:startTime.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:startTime.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
url		1..1	uriFixed Value	Element id Extension.extension:startTime.url Short description identifies the meaning of the extension Definition Source of the definition for the extension code - a logical name or a URL. Comments The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension. Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value startTime Mappings rim: n/a rim: N/A
valueTime		0..1	time	Element id Extension.extension:startTime.value[x]:valueTime Short description Value of extension Definition Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list). Data type time Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: N/A
endTime	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:endTime Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
id		0..1	string	There are no (further) constraints on this element Element id Extension.extension:endTime.id Short description xml:id (or equivalent in JSON) Definition unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces. Comments Note that FHIR strings may not exceed 1MB in size Data type string Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a
extension	C	0..*	Extension	There are no (further) constraints on this element Element id Extension.extension:endTime.extension Short description Additional Content defined by implementations Alternate names extensions, user content Definition May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension. Comments There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone. Data type Extension Slicing Unordered, Open, by url(Value) Extensions are always sliced by (at least) url Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()` Mappings rim: n/a rim: N/A
url		1..1	uriFixed Value	Element id Extension.extension:endTime.url Short description identifies the meaning of the extension Definition Source of the definition for the extension code - a logical name or a URL. Comments The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension. Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value endTime Mappings rim: n/a rim: N/A
valueTime		0..1	time	Element id Extension.extension:endTime.value[x]:valueTime Short description Value of extension Definition Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list). Data type time Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: N/A
url		1..1	uriFixed Value	Element id Extension.url Short description identifies the meaning of the extension Definition Source of the definition for the extension code - a logical name or a URL. Comments The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension. Data type uri Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Fixed value http://roche.com/fhir/rdc/StructureDefinition/careplan-timeblock-options Mappings rim: n/a rim: N/A
value[x]		0..0		There are no (further) constraints on this element Element id Extension.value[x] Short description Value of extension Definition Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list). Conditions The cardinality or value of this element may be affected by these constraints: ele-1 Constraints ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` Mappings rim: n/a rim: N/A

Details

Extension
Short	Optional Extensions Element
Definition	Optional Extension Element - found in all resources.
Cardinality	0..*
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:timeblock
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..1
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:timeblock.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:timeblock.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:timeblock.url
Short	identifies the meaning of the extension
Definition	Source of the definition for the extension code - a logical name or a URL.
Cardinality	1..1
Type	uri
Comments	The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	timeblock
Mappings	rim: n/a rim: N/A
Extension.extension:timeblock.value[x]:valueTiming
Short	Value of extension
Definition	Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).
Cardinality	0..1
Type	Timing
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: N/A
Extension.extension:timeblock.value[x]:valueTiming.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:timeblock.value[x]:valueTiming.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:timeblock.value[x]:valueTiming.event
Short	When the event occurs
Definition	Identifies specific times when the event occurs.
Cardinality	0..*
Type	dateTime
Summary	True
Requirements	In an MAR, for instance, you need to take a general specification, and turn it into a precise specification.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: QLIST<TS>
Extension.extension:timeblock.value[x]:valueTiming.repeat
Short	When the event is to occur
Definition	A set of rules that describe when the event is scheduled.
Cardinality	0..1
Type	Element
Summary	True
Requirements	Many timing schedules are determined by regular repetitions.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` tim-9: If there's an offset, there must be a when (and not C, CM, CD, CV) `offset.empty() or (when.exists() and ((when in ('C' \| 'CM' \| 'CD' \| 'CV')).not()))` tim-5: period SHALL be a non-negative value `period.exists() implies period >= 0` tim-6: If there's a periodMax, there must be a period `periodMax.empty() or period.exists()` tim-7: If there's a durationMax, there must be a duration `durationMax.empty() or duration.exists()` tim-8: If there's a countMax, there must be a count `countMax.empty() or count.exists()` tim-1: if there's a duration, there needs to be duration units `duration.empty() or durationUnit.exists()` tim-10: If there's a timeOfDay, there cannot be be a when, or vice versa `timeOfDay.empty() or when.empty()` tim-2: if there's a period, there needs to be period units `period.empty() or periodUnit.exists()` tim-4: duration SHALL be a non-negative value `duration.exists() implies duration >= 0`
Mappings	rim: n/a rim: Implies PIVL or EIVL
Extension.extension:timeblock.value[x]:valueTiming.repeat.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:timeblock.value[x]:valueTiming.repeat.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:timeblock.value[x]:valueTiming.repeat.bounds[x]
Short	Length/Range of lengths, or (Start and/or end) limits
Definition	Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.
Cardinality	0..1
Type	Duration \| Period \| Range
Summary	True
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: IVL(TS) used in a QSI
Extension.extension:timeblock.value[x]:valueTiming.repeat.count
Short	Number of times to repeat
Definition	A total count of the desired number of repetitions.
Cardinality	0..1
Type	integer
Summary	True
Requirements	Repetitions may be limited by end time or total occurrences.
Comments	If you have both bounds and count, then this should be understood as within the bounds period, until count times happens.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: PIVL.count
Extension.extension:timeblock.value[x]:valueTiming.repeat.countMax
Short	Maximum number of times to repeat
Definition	A maximum value for the count of the desired repetitions (e.g. do something 6-8 times).
Cardinality	0..1
Type	integer
Summary	True
Comments	32 bit number; for values larger than this, use decimal
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: PIVL.count
Extension.extension:timeblock.value[x]:valueTiming.repeat.duration
Short	How long when it happens
Definition	How long this thing happens for when it happens.
Cardinality	0..1
Type	decimal
Summary	True
Requirements	Some activities are not instantaneous and need to be maintained for a period of time.
Comments	For some events the duration is part of the definition of the event (e.g. IV infusions, where the duration is implicit in the specified quantity and rate). For others, it's part of the timing specification (e.g. exercise).
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: PIVL.phase
Extension.extension:timeblock.value[x]:valueTiming.repeat.durationMax
Short	How long when it happens (Max)
Definition	The upper limit of how long this thing happens for when it happens.
Cardinality	0..1
Type	decimal
Summary	True
Requirements	Some activities are not instantaneous and need to be maintained for a period of time.
Comments	For some events the duration is part of the definition of the event (e.g. IV infusions, where the duration is implicit in the specified quantity and rate). For others, it's part of the timing specification (e.g. exercise).
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: PIVL.phase
Extension.extension:timeblock.value[x]:valueTiming.repeat.durationUnit
Short	s \| min \| h \| d \| wk \| mo \| a - unit of time (UCUM)
Definition	The units of time for the duration, in UCUM units.
Cardinality	0..1
Type	code
Binding	A unit of time (units from UCUM). UnitsOfTime (required)
Summary	True
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: PIVL.phase.unit
Extension.extension:timeblock.value[x]:valueTiming.repeat.frequency
Short	Event occurs frequency times per period
Definition	The number of times to repeat the action within the specified period / period range (i.e. both period and periodMax provided).
Cardinality	0..1
Type	integer
Summary	True
Comments	32 bit number; for values larger than this, use decimal
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Default value	1
Mappings	rim: n/a rim: PIVL.phase
Extension.extension:timeblock.value[x]:valueTiming.repeat.frequencyMax
Short	Event occurs up to frequencyMax times per period
Definition	If present, indicates that the frequency is a range - so to repeat between [frequency] and [frequencyMax] times within the period or period range.
Cardinality	0..1
Type	integer
Summary	True
Comments	32 bit number; for values larger than this, use decimal
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: PIVL.phase
Extension.extension:timeblock.value[x]:valueTiming.repeat.period
Short	Event occurs frequency times per period
Definition	Indicates the duration of time over which repetitions are to occur; e.g. to express "3 times per day", 3 would be the frequency and "1 day" would be the period.
Cardinality	0..1
Type	decimal
Summary	True
Comments	Do not use a IEEE type floating point type, instead use something that works like a true decimal, with inbuilt precision (e.g. Java BigInteger)
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: PIVL.phase
Extension.extension:timeblock.value[x]:valueTiming.repeat.periodMax
Short	Upper limit of period (3-4 hours)
Definition	If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as "do this once every 3-5 days.
Cardinality	0..1
Type	decimal
Summary	True
Comments	Do not use a IEEE type floating point type, instead use something that works like a true decimal, with inbuilt precision (e.g. Java BigInteger)
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: PIVL.phase
Extension.extension:timeblock.value[x]:valueTiming.repeat.periodUnit
Short	s \| min \| h \| d \| wk \| mo \| a - unit of time (UCUM)
Definition	The units of time for the period in UCUM units.
Cardinality	0..1
Type	code
Binding	A unit of time (units from UCUM). UnitsOfTime (required)
Summary	True
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: PIVL.phase.unit
Extension.extension:timeblock.value[x]:valueTiming.repeat.dayOfWeek
Short	mon \| tue \| wed \| thu \| fri \| sat \| sun
Definition	If one or more days of week is provided, then the action happens only on the specified day(s).
Cardinality	0..*
Type	code
Binding	DaysOfWeek (required)
Summary	True
Comments	If no days are specified, the action is assumed to happen every day as otherwise specified. The elements frequency and period cannot be used as well as dayOfWeek.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:timeblock.value[x]:valueTiming.repeat.timeOfDay
Short	Time of day for action
Definition	Specified time of day for action to take place.
Cardinality	0..*
Type	time
Summary	True
Comments	When time of day is specified, it is inferred that the action happens every day (as filtered by dayofWeek) on the specified times. The elements when, frequency and period cannot be used as well as timeOfDay.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:timeblock.value[x]:valueTiming.repeat.when
Short	Regular life events the event is tied to
Definition	Real world events that the occurrence of the event should be tied to.
Cardinality	0..*
Type	code
Binding	Real world event relating to the schedule. EventTiming (required)
Summary	True
Requirements	Timings are frequently determined by occurrences such as waking, eating and sleep.
Comments	When more than one event is listed, the event is tied to the union of the specified events.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: EIVL.event
Extension.extension:timeblock.value[x]:valueTiming.repeat.offset
Short	Minutes from event (before or after)
Definition	The number of minutes from the event. If the event code does not indicate whether the minutes is before or after the event, then the offset is assumed to be after the event.
Cardinality	0..1
Type	unsignedInt
Summary	True
Comments	32 bit number; for values larger than this, use decimal
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: EIVL.offset
Extension.extension:timeblock.value[x]:valueTiming.code
Short	BID \| TID \| QID \| AM \| PM \| QD \| QOD \| Q4H \| Q6H +
Definition	A code for the timing schedule. Some codes such as BID are ubiquitous, but many institutions define their own additional codes. If a code is provided, the code is understood to be a complete statement of whatever is specified in the structured timing data, and either the code or the data may be used to interpret the Timing, with the exception that .repeat.bounds still applies over the code (and is not contained in the code).
Cardinality	0..1
Type	CodeableConcept
Binding	Code for a known / defined timing pattern. TimingAbbreviation (preferred)
Summary	True
Comments	BID etc are defined as 'at institutionally specified times'. For example, an institution may choose that BID is "always at 7am and 6pm". If it is inappropriate for this choice to be made, the code BID should not be used. Instead, a distinct organization-specific code should be used in place of the HL7-defined BID code and/or the a structured representation should be used (in this case, specifying the two event times).
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: CE/CNE/CWE rim: CD orim: fhir:CodeableConcept rdfs:subClassOf dt:CD rim: QSC.code
Extension.extension:LowerLimit
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..1
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:LowerLimit.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:LowerLimit.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:LowerLimit.url
Short	identifies the meaning of the extension
Definition	Source of the definition for the extension code - a logical name or a URL.
Cardinality	1..1
Type	uri
Comments	The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	LowerLimit
Mappings	rim: n/a rim: N/A
Extension.extension:LowerLimit.value[x]:valueQuantity
Short	Value of extension
Definition	Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).
Cardinality	0..1
Type	Quantity
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: N/A
Extension.extension:UpperLimit
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..1
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:UpperLimit.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:UpperLimit.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:UpperLimit.url
Short	identifies the meaning of the extension
Definition	Source of the definition for the extension code - a logical name or a URL.
Cardinality	1..1
Type	uri
Comments	The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	UpperLimit
Mappings	rim: n/a rim: N/A
Extension.extension:UpperLimit.value[x]:valueQuantity
Short	Value of extension
Definition	Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).
Cardinality	0..1
Type	Quantity
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: N/A
Extension.extension:CarbRatioInsulin
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..1
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:CarbRatioInsulin.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:CarbRatioInsulin.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:CarbRatioInsulin.url
Short	identifies the meaning of the extension
Definition	Source of the definition for the extension code - a logical name or a URL.
Cardinality	1..1
Type	uri
Comments	The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	CarbRatioInsulin
Mappings	rim: n/a rim: N/A
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity
Short	Value of extension
Definition	Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).
Cardinality	0..1
Type	Quantity
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: N/A
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.value
Short	Numerical value (with implicit precision)
Definition	The value of the measured amount. The value includes an implicit precision in the presentation of the value.
Cardinality	0..1
Type	decimal
Summary	True
Requirements	Precision is handled implicitly in almost all cases of measurement.
Comments	The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books).
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: SN.2 / CQ - N/A rim: PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.comparator
Short	< \| <= \| >= \| > - how to understand the value
Definition	How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
Cardinality	0..1
Type	code
Binding	How the Quantity should be understood and represented. QuantityComparator (required)
Modifier	True
Summary	True
Requirements	Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology.
Comments	This is labeled as "Is Modifier" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value.
Meaning when missing	If there is no comparator, then there is no modification of the value
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: SN.1 / CQ.1 rim: IVL properties
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.unit
Short	Unit representation
Definition	A human-readable form of the unit.
Cardinality	0..1
Type	string
Summary	True
Requirements	There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms.
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	[iU]
Mappings	rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.unit
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.system
Short	System that defines coded unit form
Definition	The identification of the system that provides the coded form of the unit.
Cardinality	0..1
Type	uri
Summary	True
Requirements	Need to know the system that defines the coded form of the unit.
Comments	see http://en.wikipedia.org/wiki/Uniform_resource_identifier
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1, qty-3
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: CO.codeSystem, PQ.translation.codeSystem
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.code
Short	Coded form of the unit
Definition	A computer processable form of the unit in some unit representation system.
Cardinality	0..1
Type	code
Summary	True
Requirements	Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest.
Comments	The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency. The context of use may additionally require a code from a particular system.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.code, MO.currency, PQ.translation.code
Extension.extension:CarbRatioCarb
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..1
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:CarbRatioCarb.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:CarbRatioCarb.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:CarbRatioCarb.url
Short	identifies the meaning of the extension
Definition	Source of the definition for the extension code - a logical name or a URL.
Cardinality	1..1
Type	uri
Comments	The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	CarbRatioCarb
Mappings	rim: n/a rim: N/A
Extension.extension:CarbRatioCarb.value[x]:valueQuantity
Short	Value of extension
Definition	Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).
Cardinality	0..1
Type	Quantity
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: N/A
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.value
Short	Numerical value (with implicit precision)
Definition	The value of the measured amount. The value includes an implicit precision in the presentation of the value.
Cardinality	0..1
Type	decimal
Summary	True
Requirements	Precision is handled implicitly in almost all cases of measurement.
Comments	The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books).
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: SN.2 / CQ - N/A rim: PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.comparator
Short	< \| <= \| >= \| > - how to understand the value
Definition	How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
Cardinality	0..1
Type	code
Binding	How the Quantity should be understood and represented. QuantityComparator (required)
Modifier	True
Summary	True
Requirements	Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology.
Comments	This is labeled as "Is Modifier" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value.
Meaning when missing	If there is no comparator, then there is no modification of the value
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: SN.1 / CQ.1 rim: IVL properties
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.unit
Short	Unit representation
Definition	A human-readable form of the unit.
Cardinality	0..1
Type	string
Summary	True
Requirements	There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms.
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	g
Mappings	rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.unit
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.system
Short	System that defines coded unit form
Definition	The identification of the system that provides the coded form of the unit.
Cardinality	0..1
Type	uri
Summary	True
Requirements	Need to know the system that defines the coded form of the unit.
Comments	see http://en.wikipedia.org/wiki/Uniform_resource_identifier
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1, qty-3
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: CO.codeSystem, PQ.translation.codeSystem
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.code
Short	Coded form of the unit
Definition	A computer processable form of the unit in some unit representation system.
Cardinality	0..1
Type	code
Summary	True
Requirements	Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest.
Comments	The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency. The context of use may additionally require a code from a particular system.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.code, MO.currency, PQ.translation.code
Extension.extension:InsulinSensitivityInsulin
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..1
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:InsulinSensitivityInsulin.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:InsulinSensitivityInsulin.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:InsulinSensitivityInsulin.url
Short	identifies the meaning of the extension
Definition	Source of the definition for the extension code - a logical name or a URL.
Cardinality	1..1
Type	uri
Comments	The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	InsulinSensitivityInsulin
Mappings	rim: n/a rim: N/A
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity
Short	Value of extension
Definition	Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).
Cardinality	0..1
Type	Quantity
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: N/A
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.value
Short	Numerical value (with implicit precision)
Definition	The value of the measured amount. The value includes an implicit precision in the presentation of the value.
Cardinality	0..1
Type	decimal
Summary	True
Requirements	Precision is handled implicitly in almost all cases of measurement.
Comments	The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books).
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: SN.2 / CQ - N/A rim: PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.comparator
Short	< \| <= \| >= \| > - how to understand the value
Definition	How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value.
Cardinality	0..1
Type	code
Binding	How the Quantity should be understood and represented. QuantityComparator (required)
Modifier	True
Summary	True
Requirements	Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology.
Comments	This is labeled as "Is Modifier" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value.
Meaning when missing	If there is no comparator, then there is no modification of the value
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: SN.1 / CQ.1 rim: IVL properties
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.unit
Short	Unit representation
Definition	A human-readable form of the unit.
Cardinality	0..1
Type	string
Summary	True
Requirements	There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms.
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	[iU]
Mappings	rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.unit
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.system
Short	System that defines coded unit form
Definition	The identification of the system that provides the coded form of the unit.
Cardinality	0..1
Type	uri
Summary	True
Requirements	Need to know the system that defines the coded form of the unit.
Comments	see http://en.wikipedia.org/wiki/Uniform_resource_identifier
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1, qty-3
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: CO.codeSystem, PQ.translation.codeSystem
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.code
Short	Coded form of the unit
Definition	A computer processable form of the unit in some unit representation system.
Cardinality	0..1
Type	code
Summary	True
Requirements	Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest.
Comments	The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency. The context of use may additionally require a code from a particular system.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a v2: (see OBX.6 etc.) / CQ.2 rim: PQ.code, MO.currency, PQ.translation.code
Extension.extension:InsulinSensitivityBG
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..1
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:InsulinSensitivityBG.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:InsulinSensitivityBG.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:InsulinSensitivityBG.url
Short	identifies the meaning of the extension
Definition	Source of the definition for the extension code - a logical name or a URL.
Cardinality	1..1
Type	uri
Comments	The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	InsulinSensitivityBG
Mappings	rim: n/a rim: N/A
Extension.extension:InsulinSensitivityBG.value[x]:valueQuantity
Short	Value of extension
Definition	Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).
Cardinality	0..1
Type	Quantity
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: N/A
Extension.extension:startTime
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:startTime.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:startTime.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:startTime.url
Short	identifies the meaning of the extension
Definition	Source of the definition for the extension code - a logical name or a URL.
Cardinality	1..1
Type	uri
Comments	The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	startTime
Mappings	rim: n/a rim: N/A
Extension.extension:startTime.value[x]:valueTime
Short	Value of extension
Definition	Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).
Cardinality	0..1
Type	time
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: N/A
Extension.extension:endTime
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:endTime.id
Short	xml:id (or equivalent in JSON)
Definition	unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
Cardinality	0..1
Type	string
Comments	Note that FHIR strings may not exceed 1MB in size
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a
Extension.extension:endTime.extension
Short	Additional Content defined by implementations
Definition	May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
Cardinality	0..*
Type	Extension
Alias	extensions, user content
Comments	There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
Slicing	Unordered, Open, by url(Value) Extensions are always sliced by (at least) url
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())` ext-1: Must have either extensions or value[x], not both `extension.exists() != value.exists()`
Mappings	rim: n/a rim: N/A
Extension.extension:endTime.url
Short	identifies the meaning of the extension
Definition	Source of the definition for the extension code - a logical name or a URL.
Cardinality	1..1
Type	uri
Comments	The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	endTime
Mappings	rim: n/a rim: N/A
Extension.extension:endTime.value[x]:valueTime
Short	Value of extension
Definition	Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).
Cardinality	0..1
Type	time
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: N/A
Extension.url
Short	identifies the meaning of the extension
Definition	Source of the definition for the extension code - a logical name or a URL.
Cardinality	1..1
Type	uri
Comments	The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Fixed Value	http://roche.com/fhir/rdc/StructureDefinition/careplan-timeblock-options
Mappings	rim: n/a rim: N/A
Extension.value[x]
Short	Value of extension
Definition	Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).
Cardinality	0..0
Type	Address \| Age \| Annotation \| Attachment \| base64Binary \| boolean \| code \| CodeableConcept \| Coding \| ContactPoint \| Count \| date \| dateTime \| decimal \| Distance \| Duration \| HumanName \| id \| Identifier \| instant \| integer \| markdown \| Meta \| Money \| oid \| Period \| positiveInt \| Quantity \| Range \| Ratio \| Reference \| SampledData \| Signature \| string \| time \| Timing \| unsignedInt \| uri
Conditions	The cardinality or value of this element may be affected by these constraints: ele-1
Constraints	ele-1: All FHIR elements must have a @value or children `hasValue() \| (children().count() > id.count())`
Mappings	rim: n/a rim: N/A

Table

Extension		0..*
Extension.id	string	0..1
Extension.extension	Extension	0..*
Extension.extension:timeblock	Extension	0..1
Extension.extension:timeblock.id	string	0..1
Extension.extension:timeblock.extension	Extension	0..*
Extension.extension:timeblock.url	uri	1..1
Extension.extension:timeblock.value[x]:valueTiming	Timing	0..1
Extension.extension:timeblock.value[x]:valueTiming.id	string	0..1
Extension.extension:timeblock.value[x]:valueTiming.extension	Extension	0..*
Extension.extension:timeblock.value[x]:valueTiming.event	dateTime	0..*
Extension.extension:timeblock.value[x]:valueTiming.repeat	Element	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.id	string	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.extension	Extension	0..*
Extension.extension:timeblock.value[x]:valueTiming.repeat.bounds[x]	Duration \| Period \| Range	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.count	integer	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.countMax	integer	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.duration	decimal	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.durationMax	decimal	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.durationUnit	code	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.frequency	integer	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.frequencyMax	integer	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.period	decimal	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.periodMax	decimal	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.periodUnit	code	0..1
Extension.extension:timeblock.value[x]:valueTiming.repeat.dayOfWeek	code	0..*
Extension.extension:timeblock.value[x]:valueTiming.repeat.timeOfDay	time	0..*
Extension.extension:timeblock.value[x]:valueTiming.repeat.when	code	0..*
Extension.extension:timeblock.value[x]:valueTiming.repeat.offset	unsignedInt	0..1
Extension.extension:timeblock.value[x]:valueTiming.code	CodeableConcept	0..1
Extension.extension:LowerLimit	Extension	0..1
Extension.extension:LowerLimit.id	string	0..1
Extension.extension:LowerLimit.extension	Extension	0..*
Extension.extension:LowerLimit.url	uri	1..1
Extension.extension:LowerLimit.value[x]:valueQuantity	Quantity	0..1
Extension.extension:UpperLimit	Extension	0..1
Extension.extension:UpperLimit.id	string	0..1
Extension.extension:UpperLimit.extension	Extension	0..*
Extension.extension:UpperLimit.url	uri	1..1
Extension.extension:UpperLimit.value[x]:valueQuantity	Quantity	0..1
Extension.extension:CarbRatioInsulin	Extension	0..1
Extension.extension:CarbRatioInsulin.id	string	0..1
Extension.extension:CarbRatioInsulin.extension	Extension	0..*
Extension.extension:CarbRatioInsulin.url	uri	1..1
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity	Quantity	0..1
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.id	string	0..1
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.extension	Extension	0..*
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.value	decimal	0..1
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.comparator	code	0..1
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.unit	string	0..1
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.system	uri	0..1
Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.code	code	0..1
Extension.extension:CarbRatioCarb	Extension	0..1
Extension.extension:CarbRatioCarb.id	string	0..1
Extension.extension:CarbRatioCarb.extension	Extension	0..*
Extension.extension:CarbRatioCarb.url	uri	1..1
Extension.extension:CarbRatioCarb.value[x]:valueQuantity	Quantity	0..1
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.id	string	0..1
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.extension	Extension	0..*
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.value	decimal	0..1
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.comparator	code	0..1
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.unit	string	0..1
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.system	uri	0..1
Extension.extension:CarbRatioCarb.value[x]:valueQuantity.code	code	0..1
Extension.extension:InsulinSensitivityInsulin	Extension	0..1
Extension.extension:InsulinSensitivityInsulin.id	string	0..1
Extension.extension:InsulinSensitivityInsulin.extension	Extension	0..*
Extension.extension:InsulinSensitivityInsulin.url	uri	1..1
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity	Quantity	0..1
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.id	string	0..1
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.extension	Extension	0..*
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.value	decimal	0..1
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.comparator	code	0..1
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.unit	string	0..1
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.system	uri	0..1
Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.code	code	0..1
Extension.extension:InsulinSensitivityBG	Extension	0..1
Extension.extension:InsulinSensitivityBG.id	string	0..1
Extension.extension:InsulinSensitivityBG.extension	Extension	0..*
Extension.extension:InsulinSensitivityBG.url	uri	1..1
Extension.extension:InsulinSensitivityBG.value[x]:valueQuantity	Quantity	0..1
Extension.extension:startTime	Extension	0..*
Extension.extension:startTime.id	string	0..1
Extension.extension:startTime.extension	Extension	0..*
Extension.extension:startTime.url	uri	1..1
Extension.extension:startTime.value[x]:valueTime	time	0..1
Extension.extension:endTime	Extension	0..*
Extension.extension:endTime.id	string	0..1
Extension.extension:endTime.extension	Extension	0..*
Extension.extension:endTime.url	uri	1..1
Extension.extension:endTime.value[x]:valueTime	time	0..1
Extension.url	uri	1..1
Extension.value[x]	Address \| Age \| Annotation \| Attachment \| base64Binary \| boolean \| code \| CodeableConcept \| Coding \| ContactPoint \| Count \| date \| dateTime \| decimal \| Distance \| Duration \| HumanName \| id \| Identifier \| instant \| integer \| markdown \| Meta \| Money \| oid \| Period \| positiveInt \| Quantity \| Range \| Ratio \| Reference \| SampledData \| Signature \| string \| time \| Timing \| unsignedInt \| uri	0..0

XML

<id value="bc85a569-876c-4e04-ba4b-9ab43696cdc1" />
<meta>
<versionId value="2" />
<lastUpdated value="2018-08-20T11:18:18.667+00:00" />
</meta>
<url value="http://roche.com/fhir/rdc/StructureDefinition/careplan-timeblock-options" />
<name value="careplan-timeblock-options" />
<status value="active" />
<date value="2018-08-20T11:18:18.1+00:00" />
<description value="This extension is used in the Bolus-CarePlan to capture the device settings for timeblocks. The Bolus Advice is based on the device settings for Bolus Advice options, consisting of three blocks: advice options, health events and timeblocks.\n\nThe scope of this extension is ACSPIX BG file.\n\nWith timeblocks patients can define specific parts of the day and adapt settings like bloodglucose target levels, carb ratio's and insuline sensitivity accordingly." />
<fhirVersion value="3.0.1" />
<kind value="complex-type" />
<abstract value="false" />
<contextType value="resource" />
<context value="CarePlan" />
<type value="Extension" />
<baseDefinition value="http://hl7.org/fhir/StructureDefinition/Extension" />
<derivation value="constraint" />
<snapshot>
<element id="Extension">
<path value="Extension" />
<short value="Optional Extensions Element" />
<definition value="Optional Extension Element - found in all resources." />
<min value="0" />
<max value="*" />
<base>
<path value="Element" />
<min value="0" />
<max value="*" />
</base>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.id">
<path value="Extension.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension">
<path value="Extension.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:timeblock">
<path value="Extension.extension" />
<sliceName value="timeblock" />
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:timeblock.id">
<path value="Extension.extension.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:timeblock.extension">
<path value="Extension.extension.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:timeblock.url">
<path value="Extension.extension.url" />
<representation value="xmlAttr" />
<short value="identifies the meaning of the extension" />
<definition value="Source of the definition for the extension code - a logical name or a URL." />
<comment value="The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension." />
<min value="1" />
<max value="1" />
<base>
<path value="Extension.url" />
<min value="1" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<fixedUri value="timeblock" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming">
<path value="Extension.extension.valueTiming" />
<sliceName value="valueTiming" />
<short value="Value of extension" />
<definition value="Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list)." />
<comment value="A stream of bytes, base64 encoded" />
<min value="0" />
<max value="1" />
<base>
<path value="Extension.value[x]" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="Timing" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.id">
<path value="Extension.extension.valueTiming.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.extension">
<path value="Extension.extension.valueTiming.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.event">
<path value="Extension.extension.valueTiming.event" />
<short value="When the event occurs" />
<definition value="Identifies specific times when the event occurs." />
<requirements value="In an MAR, for instance, you need to take a general specification, and turn it into a precise specification." />
<min value="0" />
<max value="*" />
<base>
<path value="Timing.event" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="dateTime" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="QLIST<TS>" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat">
<path value="Extension.extension.valueTiming.repeat" />
<short value="When the event is to occur" />
<definition value="A set of rules that describe when the event is scheduled." />
<requirements value="Many timing schedules are determined by regular repetitions." />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="Element" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="tim-9" />
<severity value="error" />
<human value="If there's an offset, there must be a when (and not C, CM, CD, CV)" />
<expression value="offset.empty() or (when.exists() and ((when in ('C' | 'CM' | 'CD' | 'CV')).not()))" />
<xpath value="not(exists(f:offset)) or exists(f:when)" />
</constraint>
<constraint>
<key value="tim-5" />
<severity value="error" />
<human value="period SHALL be a non-negative value" />
<expression value="period.exists() implies period >= 0" />
<xpath value="f:period/@value >= 0 or not(f:period/@value)" />
</constraint>
<constraint>
<key value="tim-6" />
<severity value="error" />
<human value="If there's a periodMax, there must be a period" />
<expression value="periodMax.empty() or period.exists()" />
<xpath value="not(exists(f:periodMax)) or exists(f:period)" />
</constraint>
<constraint>
<key value="tim-7" />
<severity value="error" />
<human value="If there's a durationMax, there must be a duration" />
<expression value="durationMax.empty() or duration.exists()" />
<xpath value="not(exists(f:durationMax)) or exists(f:duration)" />
</constraint>
<constraint>
<key value="tim-8" />
<severity value="error" />
<human value="If there's a countMax, there must be a count" />
<expression value="countMax.empty() or count.exists()" />
<xpath value="not(exists(f:countMax)) or exists(f:count)" />
</constraint>
<constraint>
<key value="tim-1" />
<severity value="error" />
<human value="if there's a duration, there needs to be duration units" />
<expression value="duration.empty() or durationUnit.exists()" />
<xpath value="not(exists(f:duration)) or exists(f:durationUnit)" />
</constraint>
<constraint>
<key value="tim-10" />
<severity value="error" />
<human value="If there's a timeOfDay, there cannot be be a when, or vice versa" />
<expression value="timeOfDay.empty() or when.empty()" />
<xpath value="not(exists(f:timeOfDay)) or not(exists(f:when))" />
</constraint>
<constraint>
<key value="tim-2" />
<severity value="error" />
<human value="if there's a period, there needs to be period units" />
<expression value="period.empty() or periodUnit.exists()" />
<xpath value="not(exists(f:period)) or exists(f:periodUnit)" />
</constraint>
<constraint>
<key value="tim-4" />
<severity value="error" />
<human value="duration SHALL be a non-negative value" />
<expression value="duration.exists() implies duration >= 0" />
<xpath value="f:duration/@value >= 0 or not(f:duration/@value)" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="Implies PIVL or EIVL" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.id">
<path value="Extension.extension.valueTiming.repeat.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.extension">
<path value="Extension.extension.valueTiming.repeat.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.bounds[x]">
<path value="Extension.extension.valueTiming.repeat.bounds[x]" />
<short value="Length/Range of lengths, or (Start and/or end) limits" />
<definition value="Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule." />
<comment value="The context of use may frequently define what kind of quantity this is and therefore what kind of units can be used. The context of use may also restrict the values for the comparator." />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.bounds[x]" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="Duration" />
</type>
<type>
<code value="Range" />
</type>
<type>
<code value="Period" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="qty-3" />
<severity value="error" />
<human value="If a code for the unit is present, the system SHALL also be present" />
<expression value="code.empty() or system.exists()" />
<xpath value="not(exists(f:code)) or exists(f:system)" />
</constraint>
<constraint>
<key value="drt-1" />
<severity value="error" />
<human value="There SHALL be a code if there is a value and it SHALL be an expression of time.  If system is present, it SHALL be UCUM." />
<expression value="code.exists() implies ((system = %ucum) and value.exists())" />
<xpath value="(f:code or not(f:value)) and (not(exists(f:system)) or f:system/@value='http://unitsofmeasure.org')" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="SN (see also Range) or CQ" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PQ, IVL<PQ>, MO, CO, depending on the values" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PQ, IVL<PQ> depending on the values" />
</mapping>
<mapping>
<identity value="rim" />
<map value="IVL(TS) used in a QSI" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.count">
<path value="Extension.extension.valueTiming.repeat.count" />
<short value="Number of times to repeat" />
<definition value="A total count of the desired number of repetitions." />
<comment value="If you have both bounds and count, then this should be understood as within the bounds period, until count times happens." />
<requirements value="Repetitions may be limited by end time or total occurrences." />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.count" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="integer" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PIVL.count" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.countMax">
<path value="Extension.extension.valueTiming.repeat.countMax" />
<short value="Maximum number of times to repeat" />
<definition value="A maximum value for the count of the desired repetitions (e.g. do something 6-8 times)." />
<comment value="32 bit number; for values larger than this, use decimal" />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.countMax" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="integer" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PIVL.count" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.duration">
<path value="Extension.extension.valueTiming.repeat.duration" />
<short value="How long when it happens" />
<definition value="How long this thing happens for when it happens." />
<comment value="For some events the duration is part of the definition of the event (e.g. IV infusions, where the duration is implicit in the specified quantity and rate). For others, it's part of the timing specification (e.g. exercise)." />
<requirements value="Some activities are not instantaneous and need to be maintained for a period of time." />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.duration" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="decimal" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PIVL.phase" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.durationMax">
<path value="Extension.extension.valueTiming.repeat.durationMax" />
<short value="How long when it happens (Max)" />
<definition value="The upper limit of how long this thing happens for when it happens." />
<comment value="For some events the duration is part of the definition of the event (e.g. IV infusions, where the duration is implicit in the specified quantity and rate). For others, it's part of the timing specification (e.g. exercise)." />
<requirements value="Some activities are not instantaneous and need to be maintained for a period of time." />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.durationMax" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="decimal" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PIVL.phase" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.durationUnit">
<path value="Extension.extension.valueTiming.repeat.durationUnit" />
<code>
<system value="http://unitsofmeasure.org" />
<code value="min" />
<display value="minute" />
<userSelected value="true" />
</code>
<short value="s | min | h | d | wk | mo | a - unit of time (UCUM)" />
<definition value="The units of time for the duration, in UCUM units." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.durationUnit" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="code" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<binding>
<extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName">
<valueString value="UnitsOfTime" />
</extension>
<strength value="required" />
<description value="A unit of time (units from UCUM)." />
<valueSetReference>
<reference value="http://hl7.org/fhir/ValueSet/units-of-time" />
</valueSetReference>
</binding>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PIVL.phase.unit" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.frequency">
<path value="Extension.extension.valueTiming.repeat.frequency" />
<short value="Event occurs frequency times per period" />
<definition value="The number of times to repeat the action within the specified period / period range (i.e. both period and periodMax provided)." />
<comment value="32 bit number; for values larger than this, use decimal" />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.frequency" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="integer" />
</type>
<defaultValueInteger value="1" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PIVL.phase" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.frequencyMax">
<path value="Extension.extension.valueTiming.repeat.frequencyMax" />
<short value="Event occurs up to frequencyMax times per period" />
<definition value="If present, indicates that the frequency is a range - so to repeat between [frequency] and [frequencyMax] times within the period or period range." />
<comment value="32 bit number; for values larger than this, use decimal" />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.frequencyMax" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="integer" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PIVL.phase" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.period">
<path value="Extension.extension.valueTiming.repeat.period" />
<short value="Event occurs frequency times per period" />
<definition value="Indicates the duration of time over which repetitions are to occur; e.g. to express "3 times per day", 3 would be the frequency and "1 day" would be the period." />
<comment value="Do not use a IEEE type floating point type, instead use something that works like a true decimal, with inbuilt precision (e.g. Java BigInteger)" />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.period" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="decimal" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PIVL.phase" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.periodMax">
<path value="Extension.extension.valueTiming.repeat.periodMax" />
<short value="Upper limit of period (3-4 hours)" />
<definition value="If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as "do this once every 3-5 days." />
<comment value="Do not use a IEEE type floating point type, instead use something that works like a true decimal, with inbuilt precision (e.g. Java BigInteger)" />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.periodMax" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="decimal" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PIVL.phase" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.periodUnit">
<path value="Extension.extension.valueTiming.repeat.periodUnit" />
<short value="s | min | h | d | wk | mo | a - unit of time (UCUM)" />
<definition value="The units of time for the period in UCUM units." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.periodUnit" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="code" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<binding>
<extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName">
<valueString value="UnitsOfTime" />
</extension>
<strength value="required" />
<description value="A unit of time (units from UCUM)." />
<valueSetReference>
<reference value="http://hl7.org/fhir/ValueSet/units-of-time" />
</valueSetReference>
</binding>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PIVL.phase.unit" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.dayOfWeek">
<path value="Extension.extension.valueTiming.repeat.dayOfWeek" />
<short value="mon | tue | wed | thu | fri | sat | sun" />
<definition value="If one or more days of week is provided, then the action happens only on the specified day(s)." />
<comment value="If no days are specified, the action is assumed to happen every day as otherwise specified. The elements frequency and period cannot be used as well as dayOfWeek." />
<min value="0" />
<max value="*" />
<base>
<path value="Timing.repeat.dayOfWeek" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="code" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<binding>
<extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName">
<valueString value="DayOfWeek" />
</extension>
<strength value="required" />
<valueSetReference>
<reference value="http://hl7.org/fhir/ValueSet/days-of-week" />
</valueSetReference>
</binding>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.timeOfDay">
<path value="Extension.extension.valueTiming.repeat.timeOfDay" />
<short value="Time of day for action" />
<definition value="Specified time of day for action to take place." />
<comment value="When time of day is specified, it is inferred that the action happens every day (as filtered by dayofWeek) on the specified times. The elements when, frequency and period cannot be used as well as timeOfDay." />
<min value="0" />
<max value="*" />
<base>
<path value="Timing.repeat.timeOfDay" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="time" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.when">
<path value="Extension.extension.valueTiming.repeat.when" />
<short value="Regular life events the event is tied to" />
<definition value="Real world events that the occurrence of the event should be tied to." />
<comment value="When more than one event is listed, the event is tied to the union of the specified events." />
<requirements value="Timings are frequently determined by occurrences such as waking, eating and sleep." />
<min value="0" />
<max value="*" />
<base>
<path value="Timing.repeat.when" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="code" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<binding>
<extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName">
<valueString value="EventTiming" />
</extension>
<strength value="required" />
<description value="Real world event relating to the schedule." />
<valueSetReference>
<reference value="http://hl7.org/fhir/ValueSet/event-timing" />
</valueSetReference>
</binding>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="EIVL.event" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.offset">
<path value="Extension.extension.valueTiming.repeat.offset" />
<short value="Minutes from event (before or after)" />
<definition value="The number of minutes from the event. If the event code does not indicate whether the minutes is before or after the event, then the offset is assumed to be after the event." />
<comment value="32 bit number; for values larger than this, use decimal" />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.repeat.offset" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="unsignedInt" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="EIVL.offset" />
</mapping>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.code">
<path value="Extension.extension.valueTiming.code" />
<short value="BID | TID | QID | AM | PM | QD | QOD | Q4H | Q6H +" />
<definition value="A code for the timing schedule. Some codes such as BID are ubiquitous, but many institutions define their own additional codes. If a code is provided, the code is understood to be a complete statement of whatever is specified in the structured timing data, and either the code or the data may be used to interpret the Timing, with the exception that .repeat.bounds still applies over the code (and is not contained in the code)." />
<comment value="BID etc are defined as 'at institutionally specified times'. For example, an institution may choose that BID is "always at 7am and 6pm".  If it is inappropriate for this choice to be made, the code BID should not be used. Instead, a distinct organization-specific code should be used in place of the HL7-defined BID code and/or the a structured representation should be used (in this case, specifying the two event times)." />
<min value="0" />
<max value="1" />
<base>
<path value="Timing.code" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="CodeableConcept" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<binding>
<extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName">
<valueString value="TimingAbbreviation" />
</extension>
<strength value="preferred" />
<description value="Code for a known / defined timing pattern." />
<valueSetReference>
<reference value="http://hl7.org/fhir/ValueSet/timing-abbreviation" />
</valueSetReference>
</binding>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="CE/CNE/CWE" />
</mapping>
<mapping>
<identity value="rim" />
<map value="CD" />
</mapping>
<mapping>
<identity value="orim" />
<map value="fhir:CodeableConcept rdfs:subClassOf dt:CD" />
</mapping>
<mapping>
<identity value="rim" />
<map value="QSC.code" />
</mapping>
</element>
<element id="Extension.extension:LowerLimit">
<path value="Extension.extension" />
<sliceName value="LowerLimit" />
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:LowerLimit.id">
<path value="Extension.extension.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:LowerLimit.extension">
<path value="Extension.extension.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:LowerLimit.url">
<path value="Extension.extension.url" />
<representation value="xmlAttr" />
<short value="identifies the meaning of the extension" />
<definition value="Source of the definition for the extension code - a logical name or a URL." />
<comment value="The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension." />
<min value="1" />
<max value="1" />
<base>
<path value="Extension.url" />
<min value="1" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<fixedUri value="LowerLimit" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:LowerLimit.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<short value="Value of extension" />
<definition value="Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list)." />
<comment value="A stream of bytes, base64 encoded" />
<min value="0" />
<max value="1" />
<base>
<path value="Extension.value[x]" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="Quantity" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:UpperLimit">
<path value="Extension.extension" />
<sliceName value="UpperLimit" />
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:UpperLimit.id">
<path value="Extension.extension.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:UpperLimit.extension">
<path value="Extension.extension.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:UpperLimit.url">
<path value="Extension.extension.url" />
<representation value="xmlAttr" />
<short value="identifies the meaning of the extension" />
<definition value="Source of the definition for the extension code - a logical name or a URL." />
<comment value="The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension." />
<min value="1" />
<max value="1" />
<base>
<path value="Extension.url" />
<min value="1" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<fixedUri value="UpperLimit" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:UpperLimit.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<short value="Value of extension" />
<definition value="Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list)." />
<comment value="A stream of bytes, base64 encoded" />
<min value="0" />
<max value="1" />
<base>
<path value="Extension.value[x]" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="Quantity" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin">
<path value="Extension.extension" />
<sliceName value="CarbRatioInsulin" />
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin.id">
<path value="Extension.extension.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin.extension">
<path value="Extension.extension.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin.url">
<path value="Extension.extension.url" />
<representation value="xmlAttr" />
<short value="identifies the meaning of the extension" />
<definition value="Source of the definition for the extension code - a logical name or a URL." />
<comment value="The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension." />
<min value="1" />
<max value="1" />
<base>
<path value="Extension.url" />
<min value="1" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<fixedUri value="CarbRatioInsulin" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<short value="Value of extension" />
<definition value="Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list)." />
<comment value="A stream of bytes, base64 encoded" />
<min value="0" />
<max value="1" />
<base>
<path value="Extension.value[x]" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="Quantity" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.id">
<path value="Extension.extension.valueQuantity.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.extension">
<path value="Extension.extension.valueQuantity.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.value">
<path value="Extension.extension.valueQuantity.value" />
<short value="Numerical value (with implicit precision)" />
<definition value="The value of the measured amount. The value includes an implicit precision in the presentation of the value." />
<comment value="The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books)." />
<requirements value="Precision is handled implicitly in almost all cases of measurement." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.value" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="decimal" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="SN.2  / CQ - N/A" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.comparator">
<path value="Extension.extension.valueQuantity.comparator" />
<short value="< | <= | >= | > - how to understand the value" />
<definition value="How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value." />
<comment value="This is labeled as "Is Modifier" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value." />
<requirements value="Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.comparator" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="code" />
</type>
<meaningWhenMissing value="If there is no comparator, then there is no modification of the value" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isModifier value="true" />
<isSummary value="true" />
<binding>
<extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName">
<valueString value="QuantityComparator" />
</extension>
<strength value="required" />
<description value="How the Quantity should be understood and represented." />
<valueSetReference>
<reference value="http://hl7.org/fhir/ValueSet/quantity-comparator" />
</valueSetReference>
</binding>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="SN.1  / CQ.1" />
</mapping>
<mapping>
<identity value="rim" />
<map value="IVL properties" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.unit">
<extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable">
<valueBoolean value="true" />
</extension>
<path value="Extension.extension.valueQuantity.unit" />
<short value="Unit representation" />
<definition value="A human-readable form of the unit." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<requirements value="There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.unit" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<fixedString value="[iU]" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="(see OBX.6 etc.) / CQ.2" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PQ.unit" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.system">
<path value="Extension.extension.valueQuantity.system" />
<short value="System that defines coded unit form" />
<definition value="The identification of the system that provides the coded form of the unit." />
<comment value="see http://en.wikipedia.org/wiki/Uniform_resource_identifier" />
<requirements value="Need to know the system that defines the coded form of the unit." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.system" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<condition value="ele-1" />
<condition value="qty-3" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="(see OBX.6 etc.) / CQ.2" />
</mapping>
<mapping>
<identity value="rim" />
<map value="CO.codeSystem, PQ.translation.codeSystem" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.code">
<path value="Extension.extension.valueQuantity.code" />
<short value="Coded form of the unit" />
<definition value="A computer processable form of the unit in some unit representation system." />
<comment value="The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency.  The context of use may additionally require a code from a particular system." />
<requirements value="Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.code" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="code" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="(see OBX.6 etc.) / CQ.2" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PQ.code, MO.currency, PQ.translation.code" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb">
<path value="Extension.extension" />
<sliceName value="CarbRatioCarb" />
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb.id">
<path value="Extension.extension.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb.extension">
<path value="Extension.extension.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb.url">
<path value="Extension.extension.url" />
<representation value="xmlAttr" />
<short value="identifies the meaning of the extension" />
<definition value="Source of the definition for the extension code - a logical name or a URL." />
<comment value="The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension." />
<min value="1" />
<max value="1" />
<base>
<path value="Extension.url" />
<min value="1" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<fixedUri value="CarbRatioCarb" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<short value="Value of extension" />
<definition value="Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list)." />
<comment value="A stream of bytes, base64 encoded" />
<min value="0" />
<max value="1" />
<base>
<path value="Extension.value[x]" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="Quantity" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb.value[x]:valueQuantity.id">
<path value="Extension.extension.valueQuantity.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb.value[x]:valueQuantity.extension">
<path value="Extension.extension.valueQuantity.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb.value[x]:valueQuantity.value">
<path value="Extension.extension.valueQuantity.value" />
<short value="Numerical value (with implicit precision)" />
<definition value="The value of the measured amount. The value includes an implicit precision in the presentation of the value." />
<comment value="The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books)." />
<requirements value="Precision is handled implicitly in almost all cases of measurement." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.value" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="decimal" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="SN.2  / CQ - N/A" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb.value[x]:valueQuantity.comparator">
<path value="Extension.extension.valueQuantity.comparator" />
<short value="< | <= | >= | > - how to understand the value" />
<definition value="How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value." />
<comment value="This is labeled as "Is Modifier" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value." />
<requirements value="Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.comparator" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="code" />
</type>
<meaningWhenMissing value="If there is no comparator, then there is no modification of the value" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isModifier value="true" />
<isSummary value="true" />
<binding>
<extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName">
<valueString value="QuantityComparator" />
</extension>
<strength value="required" />
<description value="How the Quantity should be understood and represented." />
<valueSetReference>
<reference value="http://hl7.org/fhir/ValueSet/quantity-comparator" />
</valueSetReference>
</binding>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="SN.1  / CQ.1" />
</mapping>
<mapping>
<identity value="rim" />
<map value="IVL properties" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb.value[x]:valueQuantity.unit">
<extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable">
<valueBoolean value="true" />
</extension>
<path value="Extension.extension.valueQuantity.unit" />
<short value="Unit representation" />
<definition value="A human-readable form of the unit." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<requirements value="There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.unit" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<fixedString value="g" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="(see OBX.6 etc.) / CQ.2" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PQ.unit" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb.value[x]:valueQuantity.system">
<path value="Extension.extension.valueQuantity.system" />
<short value="System that defines coded unit form" />
<definition value="The identification of the system that provides the coded form of the unit." />
<comment value="see http://en.wikipedia.org/wiki/Uniform_resource_identifier" />
<requirements value="Need to know the system that defines the coded form of the unit." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.system" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<condition value="ele-1" />
<condition value="qty-3" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="(see OBX.6 etc.) / CQ.2" />
</mapping>
<mapping>
<identity value="rim" />
<map value="CO.codeSystem, PQ.translation.codeSystem" />
</mapping>
</element>
<element id="Extension.extension:CarbRatioCarb.value[x]:valueQuantity.code">
<path value="Extension.extension.valueQuantity.code" />
<short value="Coded form of the unit" />
<definition value="A computer processable form of the unit in some unit representation system." />
<comment value="The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency.  The context of use may additionally require a code from a particular system." />
<requirements value="Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.code" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="code" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="(see OBX.6 etc.) / CQ.2" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PQ.code, MO.currency, PQ.translation.code" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin">
<path value="Extension.extension" />
<sliceName value="InsulinSensitivityInsulin" />
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.id">
<path value="Extension.extension.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.extension">
<path value="Extension.extension.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.url">
<path value="Extension.extension.url" />
<representation value="xmlAttr" />
<short value="identifies the meaning of the extension" />
<definition value="Source of the definition for the extension code - a logical name or a URL." />
<comment value="The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension." />
<min value="1" />
<max value="1" />
<base>
<path value="Extension.url" />
<min value="1" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<fixedUri value="InsulinSensitivityInsulin" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<short value="Value of extension" />
<definition value="Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list)." />
<comment value="A stream of bytes, base64 encoded" />
<min value="0" />
<max value="1" />
<base>
<path value="Extension.value[x]" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="Quantity" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.id">
<path value="Extension.extension.valueQuantity.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.extension">
<path value="Extension.extension.valueQuantity.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.value">
<path value="Extension.extension.valueQuantity.value" />
<short value="Numerical value (with implicit precision)" />
<definition value="The value of the measured amount. The value includes an implicit precision in the presentation of the value." />
<comment value="The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books)." />
<requirements value="Precision is handled implicitly in almost all cases of measurement." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.value" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="decimal" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="SN.2  / CQ - N/A" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.comparator">
<path value="Extension.extension.valueQuantity.comparator" />
<short value="< | <= | >= | > - how to understand the value" />
<definition value="How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is "<" , then the real value is < stated value." />
<comment value="This is labeled as "Is Modifier" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value." />
<requirements value="Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.comparator" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="code" />
</type>
<meaningWhenMissing value="If there is no comparator, then there is no modification of the value" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isModifier value="true" />
<isSummary value="true" />
<binding>
<extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName">
<valueString value="QuantityComparator" />
</extension>
<strength value="required" />
<description value="How the Quantity should be understood and represented." />
<valueSetReference>
<reference value="http://hl7.org/fhir/ValueSet/quantity-comparator" />
</valueSetReference>
</binding>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="SN.1  / CQ.1" />
</mapping>
<mapping>
<identity value="rim" />
<map value="IVL properties" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.unit">
<extension url="http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable">
<valueBoolean value="true" />
</extension>
<path value="Extension.extension.valueQuantity.unit" />
<short value="Unit representation" />
<definition value="A human-readable form of the unit." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<requirements value="There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.unit" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<fixedString value="[iU]" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="(see OBX.6 etc.) / CQ.2" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PQ.unit" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.system">
<path value="Extension.extension.valueQuantity.system" />
<short value="System that defines coded unit form" />
<definition value="The identification of the system that provides the coded form of the unit." />
<comment value="see http://en.wikipedia.org/wiki/Uniform_resource_identifier" />
<requirements value="Need to know the system that defines the coded form of the unit." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.system" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<condition value="ele-1" />
<condition value="qty-3" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="(see OBX.6 etc.) / CQ.2" />
</mapping>
<mapping>
<identity value="rim" />
<map value="CO.codeSystem, PQ.translation.codeSystem" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.code">
<path value="Extension.extension.valueQuantity.code" />
<short value="Coded form of the unit" />
<definition value="A computer processable form of the unit in some unit representation system." />
<comment value="The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency.  The context of use may additionally require a code from a particular system." />
<requirements value="Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest." />
<min value="0" />
<max value="1" />
<base>
<path value="Quantity.code" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="code" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<isSummary value="true" />
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="v2" />
<map value="(see OBX.6 etc.) / CQ.2" />
</mapping>
<mapping>
<identity value="rim" />
<map value="PQ.code, MO.currency, PQ.translation.code" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityBG">
<path value="Extension.extension" />
<sliceName value="InsulinSensitivityBG" />
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityBG.id">
<path value="Extension.extension.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityBG.extension">
<path value="Extension.extension.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityBG.url">
<path value="Extension.extension.url" />
<representation value="xmlAttr" />
<short value="identifies the meaning of the extension" />
<definition value="Source of the definition for the extension code - a logical name or a URL." />
<comment value="The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension." />
<min value="1" />
<max value="1" />
<base>
<path value="Extension.url" />
<min value="1" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<fixedUri value="InsulinSensitivityBG" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:InsulinSensitivityBG.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<short value="Value of extension" />
<definition value="Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list)." />
<comment value="A stream of bytes, base64 encoded" />
<min value="0" />
<max value="1" />
<base>
<path value="Extension.value[x]" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="Quantity" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:startTime">
<path value="Extension.extension" />
<sliceName value="startTime" />
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:startTime.id">
<path value="Extension.extension.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:startTime.extension">
<path value="Extension.extension.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:startTime.url">
<path value="Extension.extension.url" />
<representation value="xmlAttr" />
<short value="identifies the meaning of the extension" />
<definition value="Source of the definition for the extension code - a logical name or a URL." />
<comment value="The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension." />
<min value="1" />
<max value="1" />
<base>
<path value="Extension.url" />
<min value="1" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<fixedUri value="startTime" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:startTime.value[x]:valueTime">
<path value="Extension.extension.valueTime" />
<sliceName value="valueTime" />
<short value="Value of extension" />
<definition value="Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list)." />
<comment value="A stream of bytes, base64 encoded" />
<min value="0" />
<max value="1" />
<base>
<path value="Extension.value[x]" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="time" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:endTime">
<path value="Extension.extension" />
<sliceName value="endTime" />
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:endTime.id">
<path value="Extension.extension.id" />
<representation value="xmlAttr" />
<short value="xml:id (or equivalent in JSON)" />
<definition value="unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces." />
<comment value="Note that FHIR strings may not exceed 1MB in size" />
<min value="0" />
<max value="1" />
<base>
<path value="Element.id" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="string" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
</element>
<element id="Extension.extension:endTime.extension">
<path value="Extension.extension.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<description value="Extensions are always sliced by (at least) url" />
<rules value="open" />
</slicing>
<short value="Additional Content defined by implementations" />
<definition value="May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension." />
<comment value="There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone." />
<alias value="extensions" />
<alias value="user content" />
<min value="0" />
<max value="*" />
<base>
<path value="Element.extension" />
<min value="0" />
<max value="*" />
</base>
<type>
<code value="Extension" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<constraint>
<key value="ext-1" />
<severity value="error" />
<human value="Must have either extensions or value[x], not both" />
<expression value="extension.exists() != value.exists()" />
<xpath value="exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:endTime.url">
<path value="Extension.extension.url" />
<representation value="xmlAttr" />
<short value="identifies the meaning of the extension" />
<definition value="Source of the definition for the extension code - a logical name or a URL." />
<comment value="The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension." />
<min value="1" />
<max value="1" />
<base>
<path value="Extension.url" />
<min value="1" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<fixedUri value="endTime" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.extension:endTime.value[x]:valueTime">
<path value="Extension.extension.valueTime" />
<sliceName value="valueTime" />
<short value="Value of extension" />
<definition value="Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list)." />
<comment value="A stream of bytes, base64 encoded" />
<min value="0" />
<max value="1" />
<base>
<path value="Extension.value[x]" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="time" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.url">
<path value="Extension.url" />
<representation value="xmlAttr" />
<short value="identifies the meaning of the extension" />
<definition value="Source of the definition for the extension code - a logical name or a URL." />
<comment value="The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension." />
<min value="1" />
<max value="1" />
<base>
<path value="Extension.url" />
<min value="1" />
<max value="1" />
</base>
<type>
<code value="uri" />
</type>
<fixedUri value="http://roche.com/fhir/rdc/StructureDefinition/careplan-timeblock-options" />
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
<element id="Extension.value[x]">
<path value="Extension.value[x]" />
<short value="Value of extension" />
<definition value="Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list)." />
<comment value="A stream of bytes, base64 encoded" />
<min value="0" />
<max value="0" />
<base>
<path value="Extension.value[x]" />
<min value="0" />
<max value="1" />
</base>
<type>
<code value="base64Binary" />
</type>
<type>
<code value="boolean" />
</type>
<type>
<code value="code" />
</type>
<type>
<code value="date" />
</type>
<type>
<code value="dateTime" />
</type>
<type>
<code value="decimal" />
</type>
<type>
<code value="id" />
</type>
<type>
<code value="instant" />
</type>
<type>
<code value="integer" />
</type>
<type>
<code value="markdown" />
</type>
<type>
<code value="oid" />
</type>
<type>
<code value="positiveInt" />
</type>
<type>
<code value="string" />
</type>
<type>
<code value="time" />
</type>
<type>
<code value="unsignedInt" />
</type>
<type>
<code value="uri" />
</type>
<type>
<code value="Address" />
</type>
<type>
<code value="Age" />
</type>
<type>
<code value="Annotation" />
</type>
<type>
<code value="Attachment" />
</type>
<type>
<code value="CodeableConcept" />
</type>
<type>
<code value="Coding" />
</type>
<type>
<code value="ContactPoint" />
</type>
<type>
<code value="Count" />
</type>
<type>
<code value="Distance" />
</type>
<type>
<code value="Duration" />
</type>
<type>
<code value="HumanName" />
</type>
<type>
<code value="Identifier" />
</type>
<type>
<code value="Money" />
</type>
<type>
<code value="Period" />
</type>
<type>
<code value="Quantity" />
</type>
<type>
<code value="Range" />
</type>
<type>
<code value="Ratio" />
</type>
<type>
<code value="Reference" />
</type>
<type>
<code value="SampledData" />
</type>
<type>
<code value="Signature" />
</type>
<type>
<code value="Timing" />
</type>
<type>
<code value="Meta" />
</type>
<condition value="ele-1" />
<constraint>
<key value="ele-1" />
<severity value="error" />
<human value="All FHIR elements must have a @value or children" />
<expression value="hasValue() | (children().count() > id.count())" />
<xpath value="@value|f:*|h:div" />
</constraint>
<mapping>
<identity value="rim" />
<map value="n/a" />
</mapping>
<mapping>
<identity value="rim" />
<map value="N/A" />
</mapping>
</element>
</snapshot>
<differential>
<element id="Extension.extension">
<path value="Extension.extension" />
<slicing>
<discriminator>
<type value="value" />
<path value="url" />
</discriminator>
<rules value="open" />
</slicing>
</element>
<element id="Extension.extension:timeblock">
<path value="Extension.extension" />
<sliceName value="timeblock" />
<max value="1" />
</element>
<element id="Extension.extension:timeblock.url">
<path value="Extension.extension.url" />
<fixedUri value="timeblock" />
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming">
<path value="Extension.extension.valueTiming" />
<sliceName value="valueTiming" />
<type>
<code value="Timing" />
</type>
</element>
<element id="Extension.extension:timeblock.value[x]:valueTiming.repeat.durationUnit">
<path value="Extension.extension.valueTiming.repeat.durationUnit" />
<code>
<system value="http://unitsofmeasure.org" />
<code value="min" />
<display value="minute" />
<userSelected value="true" />
</code>
</element>
<element id="Extension.extension:LowerLimit">
<path value="Extension.extension" />
<sliceName value="LowerLimit" />
<max value="1" />
</element>
<element id="Extension.extension:LowerLimit.url">
<path value="Extension.extension.url" />
<fixedUri value="LowerLimit" />
</element>
<element id="Extension.extension:LowerLimit.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<type>
<code value="Quantity" />
</type>
</element>
<element id="Extension.extension:UpperLimit">
<path value="Extension.extension" />
<sliceName value="UpperLimit" />
<max value="1" />
</element>
<element id="Extension.extension:UpperLimit.url">
<path value="Extension.extension.url" />
<fixedUri value="UpperLimit" />
</element>
<element id="Extension.extension:UpperLimit.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<type>
<code value="Quantity" />
</type>
</element>
<element id="Extension.extension:CarbRatioInsulin">
<path value="Extension.extension" />
<sliceName value="CarbRatioInsulin" />
<max value="1" />
</element>
<element id="Extension.extension:CarbRatioInsulin.url">
<path value="Extension.extension.url" />
<fixedUri value="CarbRatioInsulin" />
</element>
<element id="Extension.extension:CarbRatioInsulin.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<type>
<code value="Quantity" />
</type>
</element>
<element id="Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.unit">
<path value="Extension.extension.valueQuantity.unit" />
<fixedString value="[iU]" />
</element>
<element id="Extension.extension:CarbRatioCarb">
<path value="Extension.extension" />
<sliceName value="CarbRatioCarb" />
<max value="1" />
</element>
<element id="Extension.extension:CarbRatioCarb.url">
<path value="Extension.extension.url" />
<fixedUri value="CarbRatioCarb" />
</element>
<element id="Extension.extension:CarbRatioCarb.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<type>
<code value="Quantity" />
</type>
</element>
<element id="Extension.extension:CarbRatioCarb.value[x]:valueQuantity.unit">
<path value="Extension.extension.valueQuantity.unit" />
<fixedString value="g" />
</element>
<element id="Extension.extension:InsulinSensitivityInsulin">
<path value="Extension.extension" />
<sliceName value="InsulinSensitivityInsulin" />
<max value="1" />
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.url">
<path value="Extension.extension.url" />
<fixedUri value="InsulinSensitivityInsulin" />
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<type>
<code value="Quantity" />
</type>
</element>
<element id="Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.unit">
<path value="Extension.extension.valueQuantity.unit" />
<fixedString value="[iU]" />
</element>
<element id="Extension.extension:InsulinSensitivityBG">
<path value="Extension.extension" />
<sliceName value="InsulinSensitivityBG" />
<max value="1" />
</element>
<element id="Extension.extension:InsulinSensitivityBG.url">
<path value="Extension.extension.url" />
<fixedUri value="InsulinSensitivityBG" />
</element>
<element id="Extension.extension:InsulinSensitivityBG.value[x]:valueQuantity">
<path value="Extension.extension.valueQuantity" />
<sliceName value="valueQuantity" />
<type>
<code value="Quantity" />
</type>
</element>
<element id="Extension.extension:startTime">
<path value="Extension.extension" />
<sliceName value="startTime" />
</element>
<element id="Extension.extension:startTime.url">
<path value="Extension.extension.url" />
<fixedUri value="startTime" />
</element>
<element id="Extension.extension:startTime.value[x]:valueTime">
<path value="Extension.extension.valueTime" />
<sliceName value="valueTime" />
<type>
<code value="time" />
</type>
</element>
<element id="Extension.extension:endTime">
<path value="Extension.extension" />
<sliceName value="endTime" />
</element>
<element id="Extension.extension:endTime.url">
<path value="Extension.extension.url" />
<fixedUri value="endTime" />
</element>
<element id="Extension.extension:endTime.value[x]:valueTime">
<path value="Extension.extension.valueTime" />
<sliceName value="valueTime" />
<type>
<code value="time" />
</type>
</element>
<element id="Extension.url">
<path value="Extension.url" />
<fixedUri value="http://roche.com/fhir/rdc/StructureDefinition/careplan-timeblock-options" />
</element>
<element id="Extension.value[x]">
<path value="Extension.value[x]" />
<max value="0" />
</element>
</differential>

</StructureDefinition>

JSON

{

"resourceType": "StructureDefinition",
"id": "bc85a569-876c-4e04-ba4b-9ab43696cdc1",
"meta": {
"versionId": "2",
"lastUpdated": "2018-08-20T11:18:18.667+00:00"
},
"url": "http://roche.com/fhir/rdc/StructureDefinition/careplan-timeblock-options",
"name": "careplan-timeblock-options",
"status": "active",
"date": "2018-08-20T11:18:18.1+00:00",
"description": "This extension is used in the Bolus-CarePlan to capture the device settings for timeblocks. The Bolus Advice is based on the device settings for Bolus Advice options, consisting of three blocks: advice options, health events and timeblocks.\n\nThe scope of this extension is ACSPIX BG file.\n\nWith timeblocks patients can define specific parts of the day and adapt settings like bloodglucose target levels, carb ratio's and insuline sensitivity accordingly.",
"fhirVersion": "3.0.1",
"kind": "complex-type",
"abstract": false,
"contextType": "resource",
"context": [
"CarePlan"
],
"type": "Extension",
"baseDefinition": "http://hl7.org/fhir/StructureDefinition/Extension",
"derivation": "constraint",
"snapshot": {
"element": [
{
"id": "Extension",
"path": "Extension",
"short": "Optional Extensions Element",
"definition": "Optional Extension Element - found in all resources.",
"min": 0,
"max": "*",
"base": {
"path": "Element",
"min": 0,
"max": "*"
},
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.id",
"path": "Extension.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension",
"path": "Extension.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:timeblock",
"path": "Extension.extension",
"sliceName": "timeblock",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "1",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:timeblock.id",
"path": "Extension.extension.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:timeblock.extension",
"path": "Extension.extension.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:timeblock.url",
"path": "Extension.extension.url",
"representation": [
"xmlAttr"
],
"short": "identifies the meaning of the extension",
"definition": "Source of the definition for the extension code - a logical name or a URL.",
"comment": "The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.",
"min": 1,
"max": "1",
"base": {
"path": "Extension.url",
"min": 1,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"fixedUri": "timeblock",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming",
"path": "Extension.extension.valueTiming",
"sliceName": "valueTiming",
"short": "Value of extension",
"definition": "Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).",
"comment": "A stream of bytes, base64 encoded",
"min": 0,
"max": "1",
"base": {
"path": "Extension.value[x]",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Timing"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.id",
"path": "Extension.extension.valueTiming.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.extension",
"path": "Extension.extension.valueTiming.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.event",
"path": "Extension.extension.valueTiming.event",
"short": "When the event occurs",
"definition": "Identifies specific times when the event occurs.",
"requirements": "In an MAR, for instance, you need to take a general specification, and turn it into a precise specification.",
"min": 0,
"max": "*",
"base": {
"path": "Timing.event",
"min": 0,
"max": "*"
},
"type": [
{
"code": "dateTime"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "QLIST<TS>"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat",
"path": "Extension.extension.valueTiming.repeat",
"short": "When the event is to occur",
"definition": "A set of rules that describe when the event is scheduled.",
"requirements": "Many timing schedules are determined by regular repetitions.",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Element"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "tim-9",
"severity": "error",
"human": "If there's an offset, there must be a when (and not C, CM, CD, CV)",
"expression": "offset.empty() or (when.exists() and ((when in ('C' | 'CM' | 'CD' | 'CV')).not()))",
"xpath": "not(exists(f:offset)) or exists(f:when)"
},
{
"key": "tim-5",
"severity": "error",
"human": "period SHALL be a non-negative value",
"expression": "period.exists() implies period >= 0",
"xpath": "f:period/@value >= 0 or not(f:period/@value)"
},
{
"key": "tim-6",
"severity": "error",
"human": "If there's a periodMax, there must be a period",
"expression": "periodMax.empty() or period.exists()",
"xpath": "not(exists(f:periodMax)) or exists(f:period)"
},
{
"key": "tim-7",
"severity": "error",
"human": "If there's a durationMax, there must be a duration",
"expression": "durationMax.empty() or duration.exists()",
"xpath": "not(exists(f:durationMax)) or exists(f:duration)"
},
{
"key": "tim-8",
"severity": "error",
"human": "If there's a countMax, there must be a count",
"expression": "countMax.empty() or count.exists()",
"xpath": "not(exists(f:countMax)) or exists(f:count)"
},
{
"key": "tim-1",
"severity": "error",
"human": "if there's a duration, there needs to be duration units",
"expression": "duration.empty() or durationUnit.exists()",
"xpath": "not(exists(f:duration)) or exists(f:durationUnit)"
},
{
"key": "tim-10",
"severity": "error",
"human": "If there's a timeOfDay, there cannot be be a when, or vice versa",
"expression": "timeOfDay.empty() or when.empty()",
"xpath": "not(exists(f:timeOfDay)) or not(exists(f:when))"
},
{
"key": "tim-2",
"severity": "error",
"human": "if there's a period, there needs to be period units",
"expression": "period.empty() or periodUnit.exists()",
"xpath": "not(exists(f:period)) or exists(f:periodUnit)"
},
{
"key": "tim-4",
"severity": "error",
"human": "duration SHALL be a non-negative value",
"expression": "duration.exists() implies duration >= 0",
"xpath": "f:duration/@value >= 0 or not(f:duration/@value)"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "Implies PIVL or EIVL"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.id",
"path": "Extension.extension.valueTiming.repeat.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.extension",
"path": "Extension.extension.valueTiming.repeat.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.bounds[x]",
"path": "Extension.extension.valueTiming.repeat.bounds[x]",
"short": "Length/Range of lengths, or (Start and/or end) limits",
"definition": "Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.",
"comment": "The context of use may frequently define what kind of quantity this is and therefore what kind of units can be used. The context of use may also restrict the values for the comparator.",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.bounds[x]",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Duration"
},
{
"code": "Range"
},
{
"code": "Period"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "qty-3",
"severity": "error",
"human": "If a code for the unit is present, the system SHALL also be present",
"expression": "code.empty() or system.exists()",
"xpath": "not(exists(f:code)) or exists(f:system)"
},
{
"key": "drt-1",
"severity": "error",
"human": "There SHALL be a code if there is a value and it SHALL be an expression of time.  If system is present, it SHALL be UCUM.",
"expression": "code.exists() implies ((system = %ucum) and value.exists())",
"xpath": "(f:code or not(f:value)) and (not(exists(f:system)) or f:system/@value='http://unitsofmeasure.org')"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "SN (see also Range) or CQ"
},
{
"identity": "rim",
"map": "PQ, IVL<PQ>, MO, CO, depending on the values"
},
{
"identity": "rim",
"map": "PQ, IVL<PQ> depending on the values"
},
{
"identity": "rim",
"map": "IVL(TS) used in a QSI"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.count",
"path": "Extension.extension.valueTiming.repeat.count",
"short": "Number of times to repeat",
"definition": "A total count of the desired number of repetitions.",
"comment": "If you have both bounds and count, then this should be understood as within the bounds period, until count times happens.",
"requirements": "Repetitions may be limited by end time or total occurrences.",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.count",
"min": 0,
"max": "1"
},
"type": [
{
"code": "integer"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "PIVL.count"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.countMax",
"path": "Extension.extension.valueTiming.repeat.countMax",
"short": "Maximum number of times to repeat",
"definition": "A maximum value for the count of the desired repetitions (e.g. do something 6-8 times).",
"comment": "32 bit number; for values larger than this, use decimal",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.countMax",
"min": 0,
"max": "1"
},
"type": [
{
"code": "integer"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "PIVL.count"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.duration",
"path": "Extension.extension.valueTiming.repeat.duration",
"short": "How long when it happens",
"definition": "How long this thing happens for when it happens.",
"comment": "For some events the duration is part of the definition of the event (e.g. IV infusions, where the duration is implicit in the specified quantity and rate). For others, it's part of the timing specification (e.g. exercise).",
"requirements": "Some activities are not instantaneous and need to be maintained for a period of time.",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.duration",
"min": 0,
"max": "1"
},
"type": [
{
"code": "decimal"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "PIVL.phase"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.durationMax",
"path": "Extension.extension.valueTiming.repeat.durationMax",
"short": "How long when it happens (Max)",
"definition": "The upper limit of how long this thing happens for when it happens.",
"comment": "For some events the duration is part of the definition of the event (e.g. IV infusions, where the duration is implicit in the specified quantity and rate). For others, it's part of the timing specification (e.g. exercise).",
"requirements": "Some activities are not instantaneous and need to be maintained for a period of time.",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.durationMax",
"min": 0,
"max": "1"
},
"type": [
{
"code": "decimal"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "PIVL.phase"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.durationUnit",
"path": "Extension.extension.valueTiming.repeat.durationUnit",
"code": [
{
"system": "http://unitsofmeasure.org",
"code": "min",
"display": "minute",
"userSelected": true
}
],
"short": "s | min | h | d | wk | mo | a - unit of time (UCUM)",
"definition": "The units of time for the duration, in UCUM units.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.durationUnit",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "UnitsOfTime"
}
],
"strength": "required",
"description": "A unit of time (units from UCUM).",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/units-of-time"
}
},
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "PIVL.phase.unit"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.frequency",
"path": "Extension.extension.valueTiming.repeat.frequency",
"short": "Event occurs frequency times per period",
"definition": "The number of times to repeat the action within the specified period / period range (i.e. both period and periodMax provided).",
"comment": "32 bit number; for values larger than this, use decimal",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.frequency",
"min": 0,
"max": "1"
},
"type": [
{
"code": "integer"
}
],
"defaultValueInteger": 1,
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "PIVL.phase"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.frequencyMax",
"path": "Extension.extension.valueTiming.repeat.frequencyMax",
"short": "Event occurs up to frequencyMax times per period",
"definition": "If present, indicates that the frequency is a range - so to repeat between [frequency] and [frequencyMax] times within the period or period range.",
"comment": "32 bit number; for values larger than this, use decimal",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.frequencyMax",
"min": 0,
"max": "1"
},
"type": [
{
"code": "integer"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "PIVL.phase"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.period",
"path": "Extension.extension.valueTiming.repeat.period",
"short": "Event occurs frequency times per period",
"definition": "Indicates the duration of time over which repetitions are to occur; e.g. to express \"3 times per day\", 3 would be the frequency and \"1 day\" would be the period.",
"comment": "Do not use a IEEE type floating point type, instead use something that works like a true decimal, with inbuilt precision (e.g. Java BigInteger)",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.period",
"min": 0,
"max": "1"
},
"type": [
{
"code": "decimal"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "PIVL.phase"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.periodMax",
"path": "Extension.extension.valueTiming.repeat.periodMax",
"short": "Upper limit of period (3-4 hours)",
"definition": "If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as \"do this once every 3-5 days.",
"comment": "Do not use a IEEE type floating point type, instead use something that works like a true decimal, with inbuilt precision (e.g. Java BigInteger)",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.periodMax",
"min": 0,
"max": "1"
},
"type": [
{
"code": "decimal"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "PIVL.phase"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.periodUnit",
"path": "Extension.extension.valueTiming.repeat.periodUnit",
"short": "s | min | h | d | wk | mo | a - unit of time (UCUM)",
"definition": "The units of time for the period in UCUM units.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.periodUnit",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "UnitsOfTime"
}
],
"strength": "required",
"description": "A unit of time (units from UCUM).",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/units-of-time"
}
},
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "PIVL.phase.unit"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.dayOfWeek",
"path": "Extension.extension.valueTiming.repeat.dayOfWeek",
"short": "mon | tue | wed | thu | fri | sat | sun",
"definition": "If one or more days of week is provided, then the action happens only on the specified day(s).",
"comment": "If no days are specified, the action is assumed to happen every day as otherwise specified. The elements frequency and period cannot be used as well as dayOfWeek.",
"min": 0,
"max": "*",
"base": {
"path": "Timing.repeat.dayOfWeek",
"min": 0,
"max": "*"
},
"type": [
{
"code": "code"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "DayOfWeek"
}
],
"strength": "required",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/days-of-week"
}
},
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.timeOfDay",
"path": "Extension.extension.valueTiming.repeat.timeOfDay",
"short": "Time of day for action",
"definition": "Specified time of day for action to take place.",
"comment": "When time of day is specified, it is inferred that the action happens every day (as filtered by dayofWeek) on the specified times. The elements when, frequency and period cannot be used as well as timeOfDay.",
"min": 0,
"max": "*",
"base": {
"path": "Timing.repeat.timeOfDay",
"min": 0,
"max": "*"
},
"type": [
{
"code": "time"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.when",
"path": "Extension.extension.valueTiming.repeat.when",
"short": "Regular life events the event is tied to",
"definition": "Real world events that the occurrence of the event should be tied to.",
"comment": "When more than one event is listed, the event is tied to the union of the specified events.",
"requirements": "Timings are frequently determined by occurrences such as waking, eating and sleep.",
"min": 0,
"max": "*",
"base": {
"path": "Timing.repeat.when",
"min": 0,
"max": "*"
},
"type": [
{
"code": "code"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "EventTiming"
}
],
"strength": "required",
"description": "Real world event relating to the schedule.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/event-timing"
}
},
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "EIVL.event"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.offset",
"path": "Extension.extension.valueTiming.repeat.offset",
"short": "Minutes from event (before or after)",
"definition": "The number of minutes from the event. If the event code does not indicate whether the minutes is before or after the event, then the offset is assumed to be after the event.",
"comment": "32 bit number; for values larger than this, use decimal",
"min": 0,
"max": "1",
"base": {
"path": "Timing.repeat.offset",
"min": 0,
"max": "1"
},
"type": [
{
"code": "unsignedInt"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "EIVL.offset"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.code",
"path": "Extension.extension.valueTiming.code",
"short": "BID | TID | QID | AM | PM | QD | QOD | Q4H | Q6H +",
"definition": "A code for the timing schedule. Some codes such as BID are ubiquitous, but many institutions define their own additional codes. If a code is provided, the code is understood to be a complete statement of whatever is specified in the structured timing data, and either the code or the data may be used to interpret the Timing, with the exception that .repeat.bounds still applies over the code (and is not contained in the code).",
"comment": "BID etc are defined as 'at institutionally specified times'. For example, an institution may choose that BID is \"always at 7am and 6pm\".  If it is inappropriate for this choice to be made, the code BID should not be used. Instead, a distinct organization-specific code should be used in place of the HL7-defined BID code and/or the a structured representation should be used (in this case, specifying the two event times).",
"min": 0,
"max": "1",
"base": {
"path": "Timing.code",
"min": 0,
"max": "1"
},
"type": [
{
"code": "CodeableConcept"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "TimingAbbreviation"
}
],
"strength": "preferred",
"description": "Code for a known / defined timing pattern.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/timing-abbreviation"
}
},
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "CE/CNE/CWE"
},
{
"identity": "rim",
"map": "CD"
},
{
"identity": "orim",
"map": "fhir:CodeableConcept rdfs:subClassOf dt:CD"
},
{
"identity": "rim",
"map": "QSC.code"
}
]
},
{
"id": "Extension.extension:LowerLimit",
"path": "Extension.extension",
"sliceName": "LowerLimit",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "1",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:LowerLimit.id",
"path": "Extension.extension.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:LowerLimit.extension",
"path": "Extension.extension.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:LowerLimit.url",
"path": "Extension.extension.url",
"representation": [
"xmlAttr"
],
"short": "identifies the meaning of the extension",
"definition": "Source of the definition for the extension code - a logical name or a URL.",
"comment": "The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.",
"min": 1,
"max": "1",
"base": {
"path": "Extension.url",
"min": 1,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"fixedUri": "LowerLimit",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:LowerLimit.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"short": "Value of extension",
"definition": "Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).",
"comment": "A stream of bytes, base64 encoded",
"min": 0,
"max": "1",
"base": {
"path": "Extension.value[x]",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Quantity"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:UpperLimit",
"path": "Extension.extension",
"sliceName": "UpperLimit",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "1",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:UpperLimit.id",
"path": "Extension.extension.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:UpperLimit.extension",
"path": "Extension.extension.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:UpperLimit.url",
"path": "Extension.extension.url",
"representation": [
"xmlAttr"
],
"short": "identifies the meaning of the extension",
"definition": "Source of the definition for the extension code - a logical name or a URL.",
"comment": "The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.",
"min": 1,
"max": "1",
"base": {
"path": "Extension.url",
"min": 1,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"fixedUri": "UpperLimit",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:UpperLimit.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"short": "Value of extension",
"definition": "Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).",
"comment": "A stream of bytes, base64 encoded",
"min": 0,
"max": "1",
"base": {
"path": "Extension.value[x]",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Quantity"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin",
"path": "Extension.extension",
"sliceName": "CarbRatioInsulin",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "1",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.id",
"path": "Extension.extension.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.extension",
"path": "Extension.extension.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.url",
"path": "Extension.extension.url",
"representation": [
"xmlAttr"
],
"short": "identifies the meaning of the extension",
"definition": "Source of the definition for the extension code - a logical name or a URL.",
"comment": "The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.",
"min": 1,
"max": "1",
"base": {
"path": "Extension.url",
"min": 1,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"fixedUri": "CarbRatioInsulin",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"short": "Value of extension",
"definition": "Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).",
"comment": "A stream of bytes, base64 encoded",
"min": 0,
"max": "1",
"base": {
"path": "Extension.value[x]",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Quantity"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.id",
"path": "Extension.extension.valueQuantity.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.extension",
"path": "Extension.extension.valueQuantity.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.value",
"path": "Extension.extension.valueQuantity.value",
"short": "Numerical value (with implicit precision)",
"definition": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
"comment": "The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books).",
"requirements": "Precision is handled implicitly in almost all cases of measurement.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.value",
"min": 0,
"max": "1"
},
"type": [
{
"code": "decimal"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "SN.2  / CQ - N/A"
},
{
"identity": "rim",
"map": "PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.comparator",
"path": "Extension.extension.valueQuantity.comparator",
"short": "< | <= | >= | > - how to understand the value",
"definition": "How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is \"<\" , then the real value is < stated value.",
"comment": "This is labeled as \"Is Modifier\" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value.",
"requirements": "Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.comparator",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "If there is no comparator, then there is no modification of the value",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuantityComparator"
}
],
"strength": "required",
"description": "How the Quantity should be understood and represented.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/quantity-comparator"
}
},
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "SN.1  / CQ.1"
},
{
"identity": "rim",
"map": "IVL properties"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.unit",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable",
"valueBoolean": true
}
],
"path": "Extension.extension.valueQuantity.unit",
"short": "Unit representation",
"definition": "A human-readable form of the unit.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"requirements": "There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.unit",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"fixedString": "[iU]",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "(see OBX.6 etc.) / CQ.2"
},
{
"identity": "rim",
"map": "PQ.unit"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.system",
"path": "Extension.extension.valueQuantity.system",
"short": "System that defines coded unit form",
"definition": "The identification of the system that provides the coded form of the unit.",
"comment": "see http://en.wikipedia.org/wiki/Uniform_resource_identifier",
"requirements": "Need to know the system that defines the coded form of the unit.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.system",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"condition": [
"ele-1",
"qty-3"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "(see OBX.6 etc.) / CQ.2"
},
{
"identity": "rim",
"map": "CO.codeSystem, PQ.translation.codeSystem"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.code",
"path": "Extension.extension.valueQuantity.code",
"short": "Coded form of the unit",
"definition": "A computer processable form of the unit in some unit representation system.",
"comment": "The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency.  The context of use may additionally require a code from a particular system.",
"requirements": "Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.code",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "(see OBX.6 etc.) / CQ.2"
},
{
"identity": "rim",
"map": "PQ.code, MO.currency, PQ.translation.code"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb",
"path": "Extension.extension",
"sliceName": "CarbRatioCarb",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "1",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.id",
"path": "Extension.extension.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.extension",
"path": "Extension.extension.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.url",
"path": "Extension.extension.url",
"representation": [
"xmlAttr"
],
"short": "identifies the meaning of the extension",
"definition": "Source of the definition for the extension code - a logical name or a URL.",
"comment": "The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.",
"min": 1,
"max": "1",
"base": {
"path": "Extension.url",
"min": 1,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"fixedUri": "CarbRatioCarb",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"short": "Value of extension",
"definition": "Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).",
"comment": "A stream of bytes, base64 encoded",
"min": 0,
"max": "1",
"base": {
"path": "Extension.value[x]",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Quantity"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.value[x]:valueQuantity.id",
"path": "Extension.extension.valueQuantity.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.value[x]:valueQuantity.extension",
"path": "Extension.extension.valueQuantity.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.value[x]:valueQuantity.value",
"path": "Extension.extension.valueQuantity.value",
"short": "Numerical value (with implicit precision)",
"definition": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
"comment": "The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books).",
"requirements": "Precision is handled implicitly in almost all cases of measurement.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.value",
"min": 0,
"max": "1"
},
"type": [
{
"code": "decimal"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "SN.2  / CQ - N/A"
},
{
"identity": "rim",
"map": "PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.value[x]:valueQuantity.comparator",
"path": "Extension.extension.valueQuantity.comparator",
"short": "< | <= | >= | > - how to understand the value",
"definition": "How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is \"<\" , then the real value is < stated value.",
"comment": "This is labeled as \"Is Modifier\" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value.",
"requirements": "Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.comparator",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "If there is no comparator, then there is no modification of the value",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuantityComparator"
}
],
"strength": "required",
"description": "How the Quantity should be understood and represented.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/quantity-comparator"
}
},
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "SN.1  / CQ.1"
},
{
"identity": "rim",
"map": "IVL properties"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.value[x]:valueQuantity.unit",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable",
"valueBoolean": true
}
],
"path": "Extension.extension.valueQuantity.unit",
"short": "Unit representation",
"definition": "A human-readable form of the unit.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"requirements": "There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.unit",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"fixedString": "g",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "(see OBX.6 etc.) / CQ.2"
},
{
"identity": "rim",
"map": "PQ.unit"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.value[x]:valueQuantity.system",
"path": "Extension.extension.valueQuantity.system",
"short": "System that defines coded unit form",
"definition": "The identification of the system that provides the coded form of the unit.",
"comment": "see http://en.wikipedia.org/wiki/Uniform_resource_identifier",
"requirements": "Need to know the system that defines the coded form of the unit.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.system",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"condition": [
"ele-1",
"qty-3"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "(see OBX.6 etc.) / CQ.2"
},
{
"identity": "rim",
"map": "CO.codeSystem, PQ.translation.codeSystem"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.value[x]:valueQuantity.code",
"path": "Extension.extension.valueQuantity.code",
"short": "Coded form of the unit",
"definition": "A computer processable form of the unit in some unit representation system.",
"comment": "The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency.  The context of use may additionally require a code from a particular system.",
"requirements": "Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.code",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "(see OBX.6 etc.) / CQ.2"
},
{
"identity": "rim",
"map": "PQ.code, MO.currency, PQ.translation.code"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin",
"path": "Extension.extension",
"sliceName": "InsulinSensitivityInsulin",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "1",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.id",
"path": "Extension.extension.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.extension",
"path": "Extension.extension.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.url",
"path": "Extension.extension.url",
"representation": [
"xmlAttr"
],
"short": "identifies the meaning of the extension",
"definition": "Source of the definition for the extension code - a logical name or a URL.",
"comment": "The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.",
"min": 1,
"max": "1",
"base": {
"path": "Extension.url",
"min": 1,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"fixedUri": "InsulinSensitivityInsulin",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"short": "Value of extension",
"definition": "Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).",
"comment": "A stream of bytes, base64 encoded",
"min": 0,
"max": "1",
"base": {
"path": "Extension.value[x]",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Quantity"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.id",
"path": "Extension.extension.valueQuantity.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.extension",
"path": "Extension.extension.valueQuantity.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.value",
"path": "Extension.extension.valueQuantity.value",
"short": "Numerical value (with implicit precision)",
"definition": "The value of the measured amount. The value includes an implicit precision in the presentation of the value.",
"comment": "The implicit precision in the value should always be honored. Monetary values have their own rules for handling precision (refer to standard accounting text books).",
"requirements": "Precision is handled implicitly in almost all cases of measurement.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.value",
"min": 0,
"max": "1"
},
"type": [
{
"code": "decimal"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "SN.2  / CQ - N/A"
},
{
"identity": "rim",
"map": "PQ.value, CO.value, MO.value, IVL.high or IVL.low depending on the value"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.comparator",
"path": "Extension.extension.valueQuantity.comparator",
"short": "< | <= | >= | > - how to understand the value",
"definition": "How the value should be understood and represented - whether the actual value is greater or less than the stated value due to measurement issues; e.g. if the comparator is \"<\" , then the real value is < stated value.",
"comment": "This is labeled as \"Is Modifier\" because the comparator modifies the interpretation of the value significantly. If there is no comparator, then there is no modification of the value.",
"requirements": "Need a framework for handling measures where the value is <5ug/L or >400mg/L due to the limitations of measuring methodology.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.comparator",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"meaningWhenMissing": "If there is no comparator, then there is no modification of the value",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isModifier": true,
"isSummary": true,
"binding": {
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString": "QuantityComparator"
}
],
"strength": "required",
"description": "How the Quantity should be understood and represented.",
"valueSetReference": {
"reference": "http://hl7.org/fhir/ValueSet/quantity-comparator"
}
},
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "SN.1  / CQ.1"
},
{
"identity": "rim",
"map": "IVL properties"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.unit",
"extension": [
{
"url": "http://hl7.org/fhir/StructureDefinition/elementdefinition-translatable",
"valueBoolean": true
}
],
"path": "Extension.extension.valueQuantity.unit",
"short": "Unit representation",
"definition": "A human-readable form of the unit.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"requirements": "There are many representations for units of measure and in many contexts, particular representations are fixed and required. I.e. mcg for micrograms.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.unit",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"fixedString": "[iU]",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "(see OBX.6 etc.) / CQ.2"
},
{
"identity": "rim",
"map": "PQ.unit"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.system",
"path": "Extension.extension.valueQuantity.system",
"short": "System that defines coded unit form",
"definition": "The identification of the system that provides the coded form of the unit.",
"comment": "see http://en.wikipedia.org/wiki/Uniform_resource_identifier",
"requirements": "Need to know the system that defines the coded form of the unit.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.system",
"min": 0,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"condition": [
"ele-1",
"qty-3"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "(see OBX.6 etc.) / CQ.2"
},
{
"identity": "rim",
"map": "CO.codeSystem, PQ.translation.codeSystem"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.code",
"path": "Extension.extension.valueQuantity.code",
"short": "Coded form of the unit",
"definition": "A computer processable form of the unit in some unit representation system.",
"comment": "The preferred system is UCUM, but SNOMED CT can also be used (for customary units) or ISO 4217 for currency.  The context of use may additionally require a code from a particular system.",
"requirements": "Need a computable form of the unit that is fixed across all forms. UCUM provides this for quantities, but SNOMED CT provides many units of interest.",
"min": 0,
"max": "1",
"base": {
"path": "Quantity.code",
"min": 0,
"max": "1"
},
"type": [
{
"code": "code"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"isSummary": true,
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "v2",
"map": "(see OBX.6 etc.) / CQ.2"
},
{
"identity": "rim",
"map": "PQ.code, MO.currency, PQ.translation.code"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityBG",
"path": "Extension.extension",
"sliceName": "InsulinSensitivityBG",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "1",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityBG.id",
"path": "Extension.extension.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityBG.extension",
"path": "Extension.extension.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityBG.url",
"path": "Extension.extension.url",
"representation": [
"xmlAttr"
],
"short": "identifies the meaning of the extension",
"definition": "Source of the definition for the extension code - a logical name or a URL.",
"comment": "The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.",
"min": 1,
"max": "1",
"base": {
"path": "Extension.url",
"min": 1,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"fixedUri": "InsulinSensitivityBG",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityBG.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"short": "Value of extension",
"definition": "Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).",
"comment": "A stream of bytes, base64 encoded",
"min": 0,
"max": "1",
"base": {
"path": "Extension.value[x]",
"min": 0,
"max": "1"
},
"type": [
{
"code": "Quantity"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:startTime",
"path": "Extension.extension",
"sliceName": "startTime",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:startTime.id",
"path": "Extension.extension.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:startTime.extension",
"path": "Extension.extension.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:startTime.url",
"path": "Extension.extension.url",
"representation": [
"xmlAttr"
],
"short": "identifies the meaning of the extension",
"definition": "Source of the definition for the extension code - a logical name or a URL.",
"comment": "The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.",
"min": 1,
"max": "1",
"base": {
"path": "Extension.url",
"min": 1,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"fixedUri": "startTime",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:startTime.value[x]:valueTime",
"path": "Extension.extension.valueTime",
"sliceName": "valueTime",
"short": "Value of extension",
"definition": "Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).",
"comment": "A stream of bytes, base64 encoded",
"min": 0,
"max": "1",
"base": {
"path": "Extension.value[x]",
"min": 0,
"max": "1"
},
"type": [
{
"code": "time"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:endTime",
"path": "Extension.extension",
"sliceName": "endTime",
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:endTime.id",
"path": "Extension.extension.id",
"representation": [
"xmlAttr"
],
"short": "xml:id (or equivalent in JSON)",
"definition": "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"comment": "Note that FHIR strings may not exceed 1MB in size",
"min": 0,
"max": "1",
"base": {
"path": "Element.id",
"min": 0,
"max": "1"
},
"type": [
{
"code": "string"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
}
]
},
{
"id": "Extension.extension:endTime.extension",
"path": "Extension.extension.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"description": "Extensions are always sliced by (at least) url",
"rules": "open"
},
"short": "Additional Content defined by implementations",
"definition": "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance  applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment": "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias": [
"extensions",
"user content"
],
"min": 0,
"max": "*",
"base": {
"path": "Element.extension",
"min": 0,
"max": "*"
},
"type": [
{
"code": "Extension"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
},
{
"key": "ext-1",
"severity": "error",
"human": "Must have either extensions or value[x], not both",
"expression": "extension.exists() != value.exists()",
"xpath": "exists(f:extension)!=exists(f:*[starts-with(local-name(.), 'value')])"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:endTime.url",
"path": "Extension.extension.url",
"representation": [
"xmlAttr"
],
"short": "identifies the meaning of the extension",
"definition": "Source of the definition for the extension code - a logical name or a URL.",
"comment": "The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.",
"min": 1,
"max": "1",
"base": {
"path": "Extension.url",
"min": 1,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"fixedUri": "endTime",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.extension:endTime.value[x]:valueTime",
"path": "Extension.extension.valueTime",
"sliceName": "valueTime",
"short": "Value of extension",
"definition": "Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).",
"comment": "A stream of bytes, base64 encoded",
"min": 0,
"max": "1",
"base": {
"path": "Extension.value[x]",
"min": 0,
"max": "1"
},
"type": [
{
"code": "time"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.url",
"path": "Extension.url",
"representation": [
"xmlAttr"
],
"short": "identifies the meaning of the extension",
"definition": "Source of the definition for the extension code - a logical name or a URL.",
"comment": "The definition may point directly to a computable or human-readable definition of the extensibility codes, or it may be a logical URI as declared in some other specification. The definition SHALL be a URI for the Structure Definition defining the extension.",
"min": 1,
"max": "1",
"base": {
"path": "Extension.url",
"min": 1,
"max": "1"
},
"type": [
{
"code": "uri"
}
],
"fixedUri": "http://roche.com/fhir/rdc/StructureDefinition/careplan-timeblock-options",
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
},
{
"id": "Extension.value[x]",
"path": "Extension.value[x]",
"short": "Value of extension",
"definition": "Value of extension - may be a resource or one of a constrained set of the data types (see Extensibility in the spec for list).",
"comment": "A stream of bytes, base64 encoded",
"min": 0,
"max": "0",
"base": {
"path": "Extension.value[x]",
"min": 0,
"max": "1"
},
"type": [
{
"code": "base64Binary"
},
{
"code": "boolean"
},
{
"code": "code"
},
{
"code": "date"
},
{
"code": "dateTime"
},
{
"code": "decimal"
},
{
"code": "id"
},
{
"code": "instant"
},
{
"code": "integer"
},
{
"code": "markdown"
},
{
"code": "oid"
},
{
"code": "positiveInt"
},
{
"code": "string"
},
{
"code": "time"
},
{
"code": "unsignedInt"
},
{
"code": "uri"
},
{
"code": "Address"
},
{
"code": "Age"
},
{
"code": "Annotation"
},
{
"code": "Attachment"
},
{
"code": "CodeableConcept"
},
{
"code": "Coding"
},
{
"code": "ContactPoint"
},
{
"code": "Count"
},
{
"code": "Distance"
},
{
"code": "Duration"
},
{
"code": "HumanName"
},
{
"code": "Identifier"
},
{
"code": "Money"
},
{
"code": "Period"
},
{
"code": "Quantity"
},
{
"code": "Range"
},
{
"code": "Ratio"
},
{
"code": "Reference"
},
{
"code": "SampledData"
},
{
"code": "Signature"
},
{
"code": "Timing"
},
{
"code": "Meta"
}
],
"condition": [
"ele-1"
],
"constraint": [
{
"key": "ele-1",
"severity": "error",
"human": "All FHIR elements must have a @value or children",
"expression": "hasValue() | (children().count() > id.count())",
"xpath": "@value|f:*|h:div"
}
],
"mapping": [
{
"identity": "rim",
"map": "n/a"
},
{
"identity": "rim",
"map": "N/A"
}
]
}
]
},
"differential": {
"element": [
{
"id": "Extension.extension",
"path": "Extension.extension",
"slicing": {
"discriminator": [
{
"type": "value",
"path": "url"
}
],
"rules": "open"
}
},
{
"id": "Extension.extension:timeblock",
"path": "Extension.extension",
"sliceName": "timeblock",
"max": "1"
},
{
"id": "Extension.extension:timeblock.url",
"path": "Extension.extension.url",
"fixedUri": "timeblock"
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming",
"path": "Extension.extension.valueTiming",
"sliceName": "valueTiming",
"type": [
{
"code": "Timing"
}
]
},
{
"id": "Extension.extension:timeblock.value[x]:valueTiming.repeat.durationUnit",
"path": "Extension.extension.valueTiming.repeat.durationUnit",
"code": [
{
"system": "http://unitsofmeasure.org",
"code": "min",
"display": "minute",
"userSelected": true
}
]
},
{
"id": "Extension.extension:LowerLimit",
"path": "Extension.extension",
"sliceName": "LowerLimit",
"max": "1"
},
{
"id": "Extension.extension:LowerLimit.url",
"path": "Extension.extension.url",
"fixedUri": "LowerLimit"
},
{
"id": "Extension.extension:LowerLimit.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"type": [
{
"code": "Quantity"
}
]
},
{
"id": "Extension.extension:UpperLimit",
"path": "Extension.extension",
"sliceName": "UpperLimit",
"max": "1"
},
{
"id": "Extension.extension:UpperLimit.url",
"path": "Extension.extension.url",
"fixedUri": "UpperLimit"
},
{
"id": "Extension.extension:UpperLimit.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"type": [
{
"code": "Quantity"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin",
"path": "Extension.extension",
"sliceName": "CarbRatioInsulin",
"max": "1"
},
{
"id": "Extension.extension:CarbRatioInsulin.url",
"path": "Extension.extension.url",
"fixedUri": "CarbRatioInsulin"
},
{
"id": "Extension.extension:CarbRatioInsulin.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"type": [
{
"code": "Quantity"
}
]
},
{
"id": "Extension.extension:CarbRatioInsulin.value[x]:valueQuantity.unit",
"path": "Extension.extension.valueQuantity.unit",
"fixedString": "[iU]"
},
{
"id": "Extension.extension:CarbRatioCarb",
"path": "Extension.extension",
"sliceName": "CarbRatioCarb",
"max": "1"
},
{
"id": "Extension.extension:CarbRatioCarb.url",
"path": "Extension.extension.url",
"fixedUri": "CarbRatioCarb"
},
{
"id": "Extension.extension:CarbRatioCarb.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"type": [
{
"code": "Quantity"
}
]
},
{
"id": "Extension.extension:CarbRatioCarb.value[x]:valueQuantity.unit",
"path": "Extension.extension.valueQuantity.unit",
"fixedString": "g"
},
{
"id": "Extension.extension:InsulinSensitivityInsulin",
"path": "Extension.extension",
"sliceName": "InsulinSensitivityInsulin",
"max": "1"
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.url",
"path": "Extension.extension.url",
"fixedUri": "InsulinSensitivityInsulin"
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"type": [
{
"code": "Quantity"
}
]
},
{
"id": "Extension.extension:InsulinSensitivityInsulin.value[x]:valueQuantity.unit",
"path": "Extension.extension.valueQuantity.unit",
"fixedString": "[iU]"
},
{
"id": "Extension.extension:InsulinSensitivityBG",
"path": "Extension.extension",
"sliceName": "InsulinSensitivityBG",
"max": "1"
},
{
"id": "Extension.extension:InsulinSensitivityBG.url",
"path": "Extension.extension.url",
"fixedUri": "InsulinSensitivityBG"
},
{
"id": "Extension.extension:InsulinSensitivityBG.value[x]:valueQuantity",
"path": "Extension.extension.valueQuantity",
"sliceName": "valueQuantity",
"type": [
{
"code": "Quantity"
}
]
},
{
"id": "Extension.extension:startTime",
"path": "Extension.extension",
"sliceName": "startTime"
},
{
"id": "Extension.extension:startTime.url",
"path": "Extension.extension.url",
"fixedUri": "startTime"
},
{
"id": "Extension.extension:startTime.value[x]:valueTime",
"path": "Extension.extension.valueTime",
"sliceName": "valueTime",
"type": [
{
"code": "time"
}
]
},
{
"id": "Extension.extension:endTime",
"path": "Extension.extension",
"sliceName": "endTime"
},
{
"id": "Extension.extension:endTime.url",
"path": "Extension.extension.url",
"fixedUri": "endTime"
},
{
"id": "Extension.extension:endTime.value[x]:valueTime",
"path": "Extension.extension.valueTime",
"sliceName": "valueTime",
"type": [
{
"code": "time"
}
]
},
{
"id": "Extension.url",
"path": "Extension.url",
"fixedUri": "http://roche.com/fhir/rdc/StructureDefinition/careplan-timeblock-options"
},
{
"id": "Extension.value[x]",
"path": "Extension.value[x]",
"max": "0"
}
]
}

}