Package :: am
Parent Package: am
Package :: archetype
The model of an archetype is straightforward at an abstract level, mimicking the structure of an archetype document as defined in the openEHR Archetype Definition Language
(ADL) document.
An archetype is a modelled as a particular kind of AUTHORED_RESOURCE, and as such, includes descriptive meta-data, language information and revision history.
The ARCHETYPE class adds identifying information, a definition - expressed in terms of constraints on instances of an object model, and an ontology. The archetype definition, the ‘main’ part of an archetype, is an instance of a C_COMPLEX_OBJECT, which is to say, the root of the constraint structure of an archetype always takes the form of a constraint on a non-primitive object type.
The last section of an archetype, the ontology, is represented by its own class, and is what allows the archetypes to be natural language-and terminology-neutral.
A utility class, VALIDITY_KIND is also included in the Archetype package. This class contains one integer attribute and three constant definitions, and is intended to be used as the type of any attribute in this constraint model whose value is logically ‘mandatory’, ‘optional’, or ‘disallowed’. It is used in this model in the classes C_Date, C_Time and C_Date_Time.
Parent Package: archetype
Class ARCHETYPE
AUTHORED_RESOURCE
| +--ARCHETYPE
Archetype equivalent to ARCHETYPED class in Common reference model.
Defines semantics of identfication, lifecycle, versioning, composition and specialisation.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
adl_version : String | 0..1 | -- | | |
archetype_id : ARCHETYPE_ID | 1 | -- | | Multi-axial identifier of this archetype in archetype space. |
concept : String | 1 | -- | | The normative meaning of the archetype as a whole, expressed as a local archetype code,
typically “at0000”. |
parent_archetype_id : ARCHETYPE_ID | 0..1 | -- | | Identifier of the specialisation parent of this archetype. |
uid : HIER_OBJECT_ID | 0..1 | -- | | OID identifier of this archetype. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| definition : C_COMPLEX_OBJECT | 1 | -- | Root node of this archetype |
| ontology : ARCHETYPE_ONTOLOGY | 1 | -- | The ontology of the archetype. |
| invariants : Set<ASSERTION> | 0..1 | * |
|
| Operations |
| Signature | Constraints | Documentation |
concept_name(a_lang : String)
:
String | | The concept name of the archetype in language.
a_lang; corresponds to the term definition of the concept_code attribute in the archetype tology. |
constraint_references_valid()
:
Boolean | | True if every CONSTRAINT_REF.reference found on a C_OBJECT node in the archetype definition is found in ontology. constraint_codes. |
internal_references_valid()
:
Boolean | | True if every ARCHETYPE_INTERNAL_REF. target_path refers to a legitimate node in the archetype definition. |
is_specialised()
:
Boolean | | True if this archetype is a specialisation of another. |
is_valid()
:
Boolean | | True if the archetype is valid overall; various tests should be used, including checks on node_ids, internal references, and constraint references. |
logical_paths(a_lang : String)
:
Set<String> | | Set of language-dependent paths extracted from archetype. Paths obey the same syntax as physical_paths, but with node_ids replaced by their meanings from the ontology. |
node_ids_valid()
:
Boolean | | True if every node_id found on a C_OBJECT node is found in ontology.term_codes. |
physical_paths()
:
Set<String> | | Set of language-independent paths extracted from archetype. Paths obey Xpath-like syntax and are formed from alternations of C_OBJECT.node_id and C_ATTRIBUTE.rm_attribute_name values. |
previous_version()
:
String | | Version of predecessor archetype of this archetype,
if any. |
short_concept_name()
:
String | | The short concept name of the archetype extracted from the archetype_id. |
specialisation_depth()
:
Integer | | Specialisation depth of this archetype; larger than 0 if this archetype has a parent.
Derived from ontology.specialisation_depth. |
version()
:
String | | Version of this archetype, extracted from id. |
| Constraints |
| Name | Expression |
| revision_history_validity | inv: is_controlled implies (revision_history <> Void
and revision_history.is_empty) |
| archetype_id_validity | inv: archetype_id <> Void |
| description_exists | inv: description <> Void |
| ontology_exists | inv: ontology <> Void |
| definition_exists | inv: definition <> Void |
| uid_validity | inv: uid <> Void implies not uid.is_empty |
| original_language_valid | inv: original_language <>void and
language <> Void
and code_set(Code_set_id_languages).has_code(original_language) |
| version_validity | inv:version <> Void and
version.is_equal(archetype_id.version_id) |
| has_parent | post: is_specialised implies parent_archetype_id <>Void |
| invariants_valid | inv: invariants <> Void implies not invariants.is_empty |
| concept_valid | inv: ontology.has_term_code(concept_code) |
| Specialisation_validity | inv: is_specialised implies specialisation_depth > 0 |
Parent Package: archetype
Class VALIDITY_KIND
An enumeration of three values which may commonly occur in constraint models.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
disallowed : Integer | 0..1 | -- | 1003 | Constant to indicate disallowed presence of something |
mandatory : Integer | 0..1 | -- | 1001 | Constant to indicate mandatory presence of something |
optional : Integer | 0..1 | -- | 1002 | Constant to indicate optional presence of something |
value : Integer | 0..1 | -- | | Actual value |
| Operations |
| Signature | Constraints | Documentation |
valid_validity(a_validity : Integer)
:
Boolean |
post: a_validity >= mandatory and
a_validity <= disallowed | Function to test validity values. |
| Constraints |
| Name | Expression |
| Validity | inv: valid_validity(value) |
Parent Package: archetype
Package :: assertion
Assertions are expressed in archetypes in typed first-order predicate logic (FOL). They are used in two places: to express archetype slot constraints, and to express invariants in complex object constraints. In both of these places, their role is to constrain something inside the archetype. Constraints on external resources such as terminologies are expressed in the constraint binding part of the archetype ontology, described in the Ontology Package
The concrete syntax of assertion statements in archetypes is designed to be compatible with the OMG Object Constraint Language (OCL). Archetype assertions are essentially statements that contain the following elements:
• variables, which are attribute names, or ADL paths terminating in attribute names (i.e. equivalent of referencing class feature in a programming language);
• manifest constants of any primitive type, plus date/time types
• arithmetic operators: +, *, -, /, ^ (exponent)
• relational operators: >, <, >=, <=, =, !=, matches
• Boolean operators: not, and, or, xor
• quantifiers applied to container variables: for_all, exists
The package described here is currently designed to allow the representation of a general-purpose binary expression tree, as would be generated by a parser. This may be replaced in the future by a more specific model, if needed.
Parent Package: assertion
Class EXPR_ITEM{Abstract}
Direct Subclassifiers:
EXPR_LEAF, EXPR_OPERATOR
Abstract parent of all expression tree items.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
type : String | 1 | -- | | Type name of this item. For leaf nodes, must be the name of a primitive type, or else a reference model type. The type for any relational or boolean operator will be “BOOLEAN”, while the type for any arithmetic operator, will be “REAL” or “INTEGER” |
| Constraints |
| Name | Expression |
| type_valid | inv: type <> Void and not type.is_empty |
Parent Package: assertion
Class EXPR_LEAF
EXPR_ITEM
| +--EXPR_LEAF
Expression tree leaf item
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
item : Any | 1 | -- | | The value referred to; a manifest constant, an attribute path, or a C_PRIMITIVE. [Future: possibly function names as well, even if not constrained in the archetype - as long as they
are in the reference model]. |
reference_type : String | 1 | -- | | Type of reference: “constant”, “attribute”, “function” |
Parent Package: assertion
Class EXPR_OPERATOR{Abstract}
EXPR_ITEM
| +--EXPR_OPERATOR
Direct Subclassifiers:
EXPR_BINARY_OPERATOR, EXPR_UNARY_OPERATOR
Abstract parent of operator types.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
operator : | 1 | -- | | Code of operator. |
precedence_overridden : Boolean | 0..1 | -- | | True if the natural precedence of operators is overridden in the expression represented by this node of the expression tree. If True, parentheses should be introduced around the totality of the syntax expression corresponding to this operator node and its operands. |
Parent Package: assertion
Class EXPR_UNARY_OPERATOR
EXPR_OPERATOR
| +--EXPR_UNARY_OPERATOR
Unary operator expression node.
| Constraints |
| Name | Expression |
| operand_valid | inv: operand <> Void |
Parent Package: assertion
Class EXPR_BINARY_OPERATOR
EXPR_OPERATOR
| +--EXPR_BINARY_OPERATOR
Binary operator expression node.
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| left_operand : EXPR_ITEM | 1 | -- | Left operand node. |
| right_operand : EXPR_ITEM | 1 | -- | Right operand node. |
| Constraints |
| Name | Expression |
| left_operand_valid | inv: left_operand <> Void |
| right_operand_valid | inv: right_operand <> Void |
Parent Package: assertion
Class ASSERTION_VARIABLE
Definition of a named variable used in an assertion expression. Note: the definition of named variables may change; still under development in ADL2.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
definition : String | 1 | -- | | Formal definition of the variable. (see ADL2 specification; still under development). |
name : String | 1 | -- | | Name of variable. |
| Constraints |
| Name | Expression |
| Definition_valid | inv: definition <> Void and not definition.is_empty |
| Name_valid | inv: name <> Void and not name.is_empty
|
Parent Package: assertion
Class ASSERTION
Structural model of a typed first order predicate logic assertion, in the form of an expression tree, including optional variable definitions.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
string_expression : String | 1 | -- | | String form of expression, in case an expression evaluator taking String expressions is used for evaluation. |
tag : String | 0..1 | -- | | Expression tag, used for differentiating multiple assertions. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| variables : List<ASSERTION_VARIABLE> | 0..1 | 0..* ordered | Definitions of variables used in the assertion expression. |
| expression : EXPR_ITEM | 1 | -- | Root of expression tree. |
| Constraints |
| Name | Expression |
| expression_valid | inv: expression <> Void and
expression.type.is_equal('Boolean') |
| tag_valid | inv: tag <> Void implies not tag.is_empty |
Parent Package: assertion
Class OPERATOR_KIND
Enumeration type for operator types in assertion expressions
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
op_and : Integer | 0..1 | -- | 2011 | And logical operator |
op_divide : Integer | 0..1 | -- | 2023 | Divide operator (‘/’) |
op_eq : Integer | 0..1 | -- | 2001 | Equals operator (‘=’ or ‘==’) |
op_exists : Integer | 0..1 | -- | 2016 | Exists quantifier operator |
op_exp : Integer | 0..1 | -- | 2024 | Exponent operator (‘^’) |
op_for_all : Integer | 0..1 | -- | 2015 | For-all quantifier operator |
op_ge : Integer | 0..1 | -- | 2005 | Greater-than or equals operator (‘>=’) |
op_gt : Integer | 0..1 | -- | 2006 | Greater-than operator (‘>’) |
op_implies : Integer | 0..1 | -- | 2014 | Implies logical operator |
op_le : Integer | 0..1 | -- | 2003 | Less-than or equals operator (‘<=’) |
op_lt : Integer | 0..1 | -- | 2004 | Less-than operator (‘<’) |
op_matches : Integer | 0..1 | -- | 2007 | Matches operator (‘matches’ or ‘is_in’) |
op_minus : Integer | 0..1 | -- | 2021 | Minus operator (‘-’) |
op_multiply : Integer | 0..1 | -- | 2022 | Multiply operator (‘*’) |
op_ne : Integer | 0..1 | -- | 2002 | Not equals operator (‘!=’ or ‘/=’ or ‘<>’) |
op_not : Integer | 0..1 | -- | 2010 | Not logical operator |
op_or : Integer | 0..1 | -- | 2012 | Or logical operator |
op_plus : Integer | 0..1 | -- | 2020 | Plus operator (‘+’) |
op_xor : Integer | 0..1 | -- | 2013 | Xor logical operator |
value : Integer | 0..1 | -- | | Actual value of this instance |
| Operations |
| Signature | Constraints | Documentation |
valid_operator(an_op : Integer)
:
Boolean |
post:an_op >= op_eq and
an_op <= op_exp | Function to test operator values. |
| Constraints |
| Name | Expression |
| validity | inv: valid_operator(value) |
Parent Package: archetype
Package :: constraint_model
The following statements summarise the main features of this package.
Any archetype definition is an instance of a C_COMPLEX_OBJECT, which can be thought of as expressing constraints on a object that is of some particular type (recorded in the attribute rm_type_name ) in a reference model, and which is larger than a simple instance of a primitive type such as String or Integer.
A C_COMPLEX_OBJECT consists of attributes of type C_ATTRIBUTE, which are constraints on the attributes (i.e. any property, including relationships) of the reference model type. Accordingly, each C_ATTRIBUTE records the name of the constrained attribute (in rm_attr_name), the existence and cardinality expressed by the constraint (depending on whether the attribute it constrains is a multiple or single relationship), and the constraint on the object to which this C_ATTRIBUTE refers via its children attribute (according to its reference model) in the form of further C_OBJECTs.
The key subtypes of C_OBJECT, are C_COMPLEX_OBJECT (described above) C_PRIMITIVE_OBJECT (constraints on instances of primitive types such as String, Integer, Boolean and Date).
The other subtypes of C_OBJECT, namely, ARCHETYPE_SLOT, ARCHETYPE_INTERNAL_REF and CONSTRAINT_REF are used to express, respectively, a `slot' where further archetypes can be used to continue describing constraints; a reference to a part of the current archetype that expresses exactly the same constraints needed at another point; and a reference to a constraint on a constraint defined in the archetype ontology, which in turn points to an external knowledge resource, such as a terminology.
All nodes in an archetype constraint structure are instances of the supertype ARCHETYPE_CONSTRAINT, which provides a number of important common features to all nodes.
Parent Package: constraint_model
Class ARCHETYPE_CONSTRAINT{Abstract}
Direct Subclassifiers:
C_ATTRIBUTE, C_OBJECT
Archetype equivalent to LOCATABLE class in openEHR Common reference model. Defines common constraints for any inheritor of LOCATABLE in any reference model.
| Operations |
| Signature | Constraints | Documentation |
has_path(a_path : String)
:
Boolean |
pre: a_path <> Void | True if the relative path a_path exists at this node. |
is_subset_of(other : ARCHETYPE_CONSTRAINT)
:
Boolean |
pre: other <> Void | True if constraints represented by other are narrower than this node. |
is_valid()
:
Boolean | | True if this node (and all its sub-nodes) is a valid archetype node for its type. This function should be implemented by each subtype to perform semantic validation of itself, and then call the is_valid function in any subparts, and generate the result appropriately. |
path()
:
String | | Path of this node relative to root of archetype. |
| Constraints |
| Name | Expression |
| path_exists | inv: path <> Void |
Parent Package: constraint_model
Class C_ATTRIBUTE{Abstract}
ARCHETYPE_CONSTRAINT
| +--C_ATTRIBUTE
Direct Subclassifiers:
C_MULTIPLE_ATTRIBUTE, C_SINGLE_ATTRIBUTE
Abstract model of constraint on any kind of attribute node.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
existence : Interval<Integer> | 1 | -- | | Constraint on every attribute, regardless of whether it is singular or of a container type, which indicates whether its target object exists or not (i.e. is mandatory or not). |
rm_attribute_name : String | 1 | -- | | Reference model attribute within the enclosing type represented by a C_OBJECT . |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| children : Set<C_OBJECT> | 0..1 | * | Child C_OBJECT nodes. Each such node represents a constraint on the type of this attribute in its reference model. Multiples occur both for multiple items in the case of container attributes, and alternatives in the case of singular attributes. |
| Constraints |
| Name | Expression |
| existence_set | inv: existence <> Void and (existence.lower >= 0 and existence.upper <= 1) |
| rm_attribute_name_valid | inv: rm_attribute_name <> Void and not rm_attribute_name.is_empty |
| children_validity | inv: any_allowed xor children <> Void |
Parent Package: constraint_model
Class C_OBJECT{Abstract}
ARCHETYPE_CONSTRAINT
| +--C_OBJECT
Direct Subclassifiers:
C_DEFINED_OBJECT, C_REFERENCE_OBJECT
Abstract model of constraint on any kind of object node.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
node_id : String | 1 | -- | | Semantic id of this node, used to differentiate sibling nodes of the same type. [Previously called `meaning']. Each node_id must be defined in the archetype ontology as a term code. |
occurrences : Interval<Integer> | 1 | -- | | Occurrences of this object node in the data, under the owning attribute. Upper limit can only be greater than 1 if owning attribute has a cardinality of more than 1). |
rm_type_name : String | 1 | -- | | Reference model type that this node corresponds to. |
| Constraints |
| Name | Expression |
| rm_type_name_valid | inv: rm_type_name <> Void and
not node_id.is_empty |
| node_id_valid | inv: node_id <> Void and not node_id.is_empty |
Parent Package: constraint_model
Class CARDINALITY
Expresses constraints on the cardinality of container objects which are the values of multiply-valued attributes, including uniqueness and ordering, providing the means to state that a container acts like a logical list, set or bag. The cardinality cannot contradict the cardinality of the corresponding attribute within the relevant reference model.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
interval : Interval<Integer> | 1 | -- | | The interval (range) of this cardinality. |
is_ordered : Boolean | 1 | -- | | True if the members of the container attribute to which this cardinality refers are ordered. |
is_unique : Boolean | 1 | -- | | True if the members of the container attribute to which this cardinality refers are unique. |
| Operations |
| Signature | Constraints | Documentation |
is_bag()
:
Boolean |
post: is_bag=not is_ordered and not is_unique | True if the semantics of this cardinality represent a set, i.e. unordered, unique membership. |
is_list()
:
Boolean |
post: is_list=is_ordered and not is_unique | True if the semantics of this cardinality represent a list, i.e. ordered, non-unique membership. |
is_set()
:
Boolean |
post: is_set=not is_ordered and is_unique | True if the semantics of this cardinality represent a bag, i.e. unordered, non-unique membership. |
| Constraints |
| Name | Expression |
| validity | inv: not interval.lower_unbounded |
Parent Package: constraint_model
Class CONSTRAINT_REF
C_REFERENCE_OBJECT
| +--CONSTRAINT_REF
Reference to a constraint described in the same archetype, but outside the main constraint structure. This is used to refer to constraints expressed in terms of external resources, such as constraints on terminology value sets.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
reference : String | 1 | -- | | Reference to a constraint in the archetype local ontology. |
| Constraints |
| Name | Expression |
| Consistency | inv: not any_allowed |
| reference_valid | inv: reference <> Void
|
Parent Package: constraint_model
Class ARCHETYPE_INTERNAL_REF
C_REFERENCE_OBJECT
| +--ARCHETYPE_INTERNAL_REF
A constraint defined by proxy, using a reference to an object constraint defined
elsewhere in the same archetype.
Note that since this object refers to another node, there are two objects with available
occurrences values. The local occurrences value on an
ARCHETYPE_INTERNAL_REF should always be used; when setting this from a serialised
form, if no occurrences is mentioned, the target occurrences should be used
(not the standard default of {1..1}); otherwise the locally specified occurrences
should be used as normal. When serialising out, if the occurrences is the same as
that of the target, it can be left out.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
target_path : String | 1 | -- | | Reference to an object node using archetype path notation. |
| Constraints |
| Name | Expression |
| consistency | inv: not any_allowed |
| target_path_valid | inv: target_path <>Void and not target_path.is_empty
and ultimate_root.has_path(target_path)
|
Parent Package: constraint_model
Class ARCHETYPE_SLOT
C_REFERENCE_OBJECT
| +--ARCHETYPE_SLOT
Constraint describing a `slot' where another archetype can occur.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
excludes : List<ASSERTION> | 0..1 | -- | | List of constraints defining other archetypes that cannot be included at this point. |
includes : List<ASSERTION> | 0..1 | -- | | List of constraints defining other archetypes that could be included at this point. |
| Constraints |
| Name | Expression |
| includes_valid | inv: includes <> Void implies not includes.is_empty |
| excludes_valid | inv: excludes <> Void implies not excludes.is_empty |
| validity | inv: any_allowed xor includes <> Void
or excludes <> Void |
Parent Package: constraint_model
Class C_SINGLE_ATTRIBUTE
C_ATTRIBUTE
| +--C_SINGLE_ATTRIBUTE
Concrete model of constraint on a single-valued attribute node. The meaning of the inherited children attribute is that they are alternatives.
| Operations |
| Signature | Constraints | Documentation |
alternatives()
:
List<C_OBJECT> | | List of alternative constraints for the single child of this attribute within the data. |
| Constraints |
| Name | Expression |
| alternatives_exists | inv: alternatives <> Void |
Parent Package: constraint_model
Class C_MULTIPLE_ATTRIBUTE
C_ATTRIBUTE
| +--C_MULTIPLE_ATTRIBUTE
Abstract model of constraint on any kind of attribute node.
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| cardinality : CARDINALITY | 0..1 | -- | Cardinality of this attribute constraint, if it constrains a container attribute. |
| Operations |
| Signature | Constraints | Documentation |
members()
:
List<C_OBJECT> | | List of constraints representing members of the container value of this attribute within the data. Semantics of the uniqueness and ordering of items in the container are given by the cardinality . |
| Constraints |
| Name | Expression |
| members_valid | inv: members <> Void and members->for_all(co: C_OBJECT | co.occurrences.upper <= 1) |
| cardinality_validity | inv: cardinality <> Void |
Parent Package: constraint_model
Class C_DOMAIN_TYPE{Abstract}
C_DEFINED_OBJECT
| +--C_DOMAIN_TYPE
Direct Subclassifiers:
C_DV_STATE, C_DV_ORDINAL, C_DV_QUANTITY, C_CODE_PHRASE
Abstract parent type of domain-specific constrainer types, to be defined in external packages.
| Constraints |
| Name | Expression |
| Assumed_value_valid | inv: has_assumed_value implies valid_value(assumed_value) |
Parent Package: constraint_model
Class C_COMPLEX_OBJECT
C_DEFINED_OBJECT
| +--C_COMPLEX_OBJECT
Constraint on complex objects, i.e. any object that consists of other object constraints.
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| attributes : Set<C_ATTRIBUTE> | 0..1 | * | List of constraints on attributes of the reference model type represented by this object.
|
| invariants : Set<ASSERTION> | 0..1 | 0..* | Invariant statements about this object. Statements are expressed in first order predicate logic, and usually refer to at least two attributes. |
| Constraints |
| Name | Expression |
| attributes_valid | inv: any_allowed xor (attributes <> Void and not
attributes.is_empty) |
Parent Package: constraint_model
Class C_PRIMITIVE_OBJECT
C_DEFINED_OBJECT
| +--C_PRIMITIVE_OBJECT
Constraint on a primitive type.
| Constraints |
| Name | Expression |
| item_exists | inv: any_allowed xor item <> Void |
Parent Package: constraint_model
Class C_DEFINED_OBJECT{Abstract}
C_OBJECT
| +--C_DEFINED_OBJECT
Direct Subclassifiers:
C_DOMAIN_TYPE, C_PRIMITIVE_OBJECT, C_COMPLEX_OBJECT
Abstract parent type of C_OBJECT subtypes that are defined by value, i.e. whosedefinitions are actually in the archetype rather than being by reference.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
assumed_value : Any | 0..1 | -- | | Value to be assumed if none sent in data |
| Operations |
| Signature | Constraints | Documentation |
any_allowed()
:
Boolean | | True if any value (i.e. instance) of the refer-ence model type would be allowed.
Redefined in descendants. |
default_value()
:
Any | | Generate a default value from this constraint object |
has_assumed_value()
:
Boolean | | True if there is an assumed value |
valid_value(a_value : Any)
:
Boolean |
pre: a_value <> Void | True if a_value is valid with respect to con-straint expressed in concrete instance of this type. |
| Constraints |
| Name | Expression |
| Assumed_value_valid | inv: has_assumed_value implies valid_value(assumed_value) |
Parent Package: constraint_model
Class C_REFERENCE_OBJECT{Abstract}
C_OBJECT
| +--C_REFERENCE_OBJECT
Direct Subclassifiers:
ARCHETYPE_SLOT, ARCHETYPE_INTERNAL_REF, CONSTRAINT_REF
Abstract parent type of C_OBJECT subtypes that are defined by reference.
Parent Package: constraint_model
Package :: primitive
Ultimately any archetype definition will devolve down to leaf node constraints on instances of primitive types. The primitives package defines the semantics of constraint on such types. Most of the types provide at least two alternative ways to represent the constraint; for example the C_DATE type allows the constraint to be expressed in the form of a pattern (defined in the ADL specification) or an Interval. Note that the interval form of dates is probably only useful for historical date checking (e.g. the date of an antique or a particular batch of vaccine), rather than constraints on future date/times.
Parent Package: primitive
Class C_STRING
C_PRIMITIVE
| +--C_STRING
Constraint on instances of STRING .
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
assumed_value : String | 0..1 | -- | | The value to assume if this item is not included in data, due to being part of an optional structure. |
list : Set<List<String>> | 0..1 | 0..* | | List of Strings specifying constraint |
list_open : Boolean | 0..1 | -- | | True if the list is being used to specify the constraint but is not considered exhaustive. |
pattern : String | 0..1 | -- | | Regular expression pattern for proposed instances of String to match. |
| Constraints |
| Name | Expression |
| pattern_exists | inv: pattern <> Void implies not pattern.is_empty |
| consistency | inv: pattern <> Void xor list <> Void |
Parent Package: primitive
Class C_BOOLEAN
C_PRIMITIVE
| +--C_BOOLEAN
Constraint on instances of Boolean .
Both attributes cannot be set to False, since this would mean that the Boolean value being constrained cannot be True or False.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
assumed_value : Boolean | 0..1 | -- | | The value to assume if this item is not included in data, due to being part of an optional structure. |
false_valid : Boolean | 1 | -- | | True if the value False is allowed |
true_valid : Boolean | 1 | -- | | True if the value True is allowed |
| Constraints |
| Name | Expression |
| Default_value_consistency | inv: (default_value.value and true_valid) or
(not default_value.value and false_valid) |
| binary_consistency | inv: true_valid or false_valid |
Parent Package: primitive
Class C_DURATION
C_PRIMITIVE
| +--C_DURATION
ISO 8601-compatible constraint on instances of Duration. In ISO 8601 terms, constraints might are of the form “PWD” (weeks and/or days), “PDTHMS” (days, hours, minutes, seconds) and so on. In official ISO 8601:2004, the ‘W’ (week) designator cannot be mixed in; allowing it is an openEHR-wide exception.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
assumed_value : Duration | 0..1 | -- | | The value to assume if this item is not included in data, due to being part of an optional structure. |
days_allowed : Boolean | 0..1 | -- | | True if days are allowed in the constrained Duration. |
fractional_seconds_allowed : Boolean | 0..1 | -- | | True if fractional seconds are allowed in the constrained Duration. |
hours_allowed : Boolean | 0..1 | -- | | True if hours are allowed in the constrained Duration. |
minutes_allowed : Boolean | 0..1 | -- | | True if minutes are allowed in the constrained Duration. |
months_allowed : Boolean | 0..1 | -- | | True if months are allowed in the constrained Duration. |
range : Interval<Duration> | 0..1 | -- | | Constraint on instances of Duration . |
seconds_allowed : Boolean | 0..1 | -- | | True if seconds are allowed in the constrained Duration. |
weeks_allowed : Boolean | 0..1 | -- | | True if weeks are allowed in the constrained Duration. |
years_allowed : Boolean | 0..1 | -- | | True if years are allowed in the constrained Duration |
| Constraints |
| Name | Expression |
| range_valid | inv: range <> Void or (years_allowed or months_allowed or
weeks_allowed or days_allowed or
hours_allowed or minutes_allowed or
seconds_allowed or fractional_seconds_allowed) |
Parent Package: primitive
Class C_DATE_TIME
C_PRIMITIVE
| +--C_DATE_TIME
ISO 8601-compatible constraint on instances of Date_Time. There is no validity flag for ‘year’, since it must always be by definition mandatory in order to have a sensible date/time at all. Syntax expressions of instances of this class include “YYYY-MM-DDT??:??:??” (date/time ith optional time) and “YYYY-MMDDTHH: MM:xx” (date/time, seconds not allowed).
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
assumed_value : Date_Time | 0..1 | -- | | The value to assume if this item is not included in data, due to being part of an optional structure. |
day_validity : VALIDITY_KIND | 0..1 | -- | | Validity of day in constrained date. |
hour_validity : VALIDITY_KIND | 0..1 | -- | | Validity of hour in constrained time. |
millisecond_validity : VALIDITY_KIND | 0..1 | -- | | Validity of millisecond in constrained time. |
minute_validity : VALIDITY_KIND | 0..1 | -- | | Validity of minute in constrained time. |
month_validity : VALIDITY_KIND | 0..1 | -- | | Validity of month in constrained date. |
range : Interval<Date_Time> | 0..1 | -- | | Range of Date_times specifying constraint |
second_validity : VALIDITY_KIND | 0..1 | -- | | Validity of second in constrained time. |
timezone_validity : VALIDITY_KIND | 0..1 | -- | | Validity of timezone in constrained date. |
| Operations |
| Signature | Constraints | Documentation |
validity_is_range()
:
Boolean | | True if validity is in the form of a range; useful for developers to check which kind of constraint has been set. |
| Constraints |
| Name | Expression |
| second_validity_disallowed | inv: second_validity = VALIDITY_KIND.disallowed
implies millisecond_validity = VALIDITY_KIND.disallowed |
| second_validity_optional | inv: second_validity = VALIDITY_KIND.optional implies
(millisecond_validity = VALIDITY_KIND.optional or
millisecond_validity = VALIDITY_KIND.disallowed) |
| minute_validity_optional | inv: minute_validity = VALIDITY_KIND.optional implies
(second_validity = VALIDITY_KIND.optional or second_validity = VALIDITY_KIND.disallowed) |
| minute_validity_disallowed | inv: minute_validity = VALIDITY_KIND.disallowed
implies second_validity = VALIDITY_KIND.disallowed |
| hour_validity_disallowed | inv: hour_validity = VALIDITY_KIND.disallowed
implies minute_validity = VALIDITY_KIND.disallowed |
| day_validity_disallowed | inv: day_validity = VALIDITY_KIND.disallowed implies
hour_validity = VALIDITY_KIND.disallowed |
| month_validity_disallowed | inv: month_validity = VALIDITY_KIND.disallowed
implies day_validity = VALIDITY_KIND.disallowed |
| day_validity_optional | inv: day_validity = VALIDITY_KIND.optional implies
(hour_validity = VALIDITY_KIND.optional or hour_validity =VALIDITY_KIND.disallowed)
|
| hour_validity_optional | inv: hour_validity = VALIDITY_KIND.optional implies
(minute_validity = VALIDITY_KIND.optional or minute_validity = VALIDITY_KIND.disallowed) |
| validity_is_range | inv: validity_is_range = (range <> Void) |
| month_validity_optional | inv: month_validity = VALIDITY_KIND.optional implies
(day_validity = VALIDITY_KIND.optional or
day_validity = VALIDITY_KIND.disallowed)
|
Parent Package: primitive
Class C_INTEGER
C_PRIMITIVE
| +--C_INTEGER
Constraint on instances of Integer .
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
assumed_value : Integer | 0..1 | -- | | The value to assume if this item is not included in data, due to being part of an optional structure. |
list : Set<Integer> | 0..1 | -- | | Set of Integers specifying constraint |
range : Interval<Integer> | 0..1 | -- | | Range of Integers specifying constraint |
| Constraints |
| Name | Expression |
| consistency | inv: list <> Void xor range <> Void |
Parent Package: primitive
Class C_TIME
C_PRIMITIVE
| +--C_TIME
ISO 8601-compatible constraint on instances of Time. There is no validity flag for ‘hour’, since it must always be by definition mandatory in order to have a sensible time at all. Syntax xpressions of instances of this class include “HH:??:xx” (time with optional minutes and seconds not allowed).
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
assumed_value : Time | 0..1 | -- | | The value to assume if this item is not included in data, due to being part of an optional structure. |
millisecond_validity : VALIDITY_KIND | 0..1 | -- | | Validity of millisecond in constrained time. |
minute_validity : VALIDITY_KIND | 0..1 | -- | | Validity of minute in constrained time. |
range : Interval<Time> | 0..1 | -- | | Interval of Times specifying constraint |
second_validity : VALIDITY_KIND | 0..1 | -- | | Validity of second in constrained time. |
timezone_validity : VALIDITY_KIND | 0..1 | -- | | Validity of timezone in constrained date. |
| Operations |
| Signature | Constraints | Documentation |
validity_is_range()
:
Boolean | | True if validity is in the form of a range; useful for developers to check which kind of constraint has been set. |
| Constraints |
| Name | Expression |
| minute_validity_optional | inv: minute_validity = VALIDITY_KIND.optional implies
(second_validity = VALIDITY_KIND.optional or second_validity =
VALIDITY_KIND.disallowed) |
| second_validity_disallowed | inv: second_validity = VALIDITY_KIND.disallowed
implies millisecond_validity = VALIDITY_KIND.disallowed |
| second_validity_optional: | inv: second_validity = VALIDITY_KIND.optional implies
(millisecond_validity = VALIDITY_KIND.optional or
millisecond_validity = VALIDITY_KIND.disallowed) |
| minute_validity_disallowed | inv: minute_validity = VALIDITY_KIND.disallowed
implies second_validity = VALIDITY_KIND.disallowed |
| validity_is_range | inv: validity_is_range = (range <> Void) |
Parent Package: primitive
Class C_REAL
C_PRIMITIVE
| +--C_REAL
Constraint on instances of Real .
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
assumed_value : Real | 0..1 | -- | | The value to assume if this item is not included in data, due to being part of an optional structure. |
list : Set<Set<Real>> | 0..1 | 0..* | | Set of Reals specifying constraint |
range : Interval<Real> | 0..1 | -- | | Range of Real specifying constraint |
| Constraints |
| Name | Expression |
| consistency | inv: list <> Void xor range <> Void |
Parent Package: primitive
Class C_DATE
C_PRIMITIVE
| +--C_DATE
ISO 8601-compatible constraint on instances of Date in the form either of a set of validity values, or an actual date range. There is no validity flag for ‘year’, since it must always be by definition mandatory in order to have a sensible date at all.
Syntax expressions of instances of this class include “YYYY-??-??” (date with optional month and day).
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
assumed_value : Date | 0..1 | -- | | The value to assume if this item is not included in data, due to being part of an optional structure. |
day_validity : VALIDITY_KIND | 0..1 | -- | | Validity of day in constrained date. |
month_validity : VALIDITY_KIND | 0..1 | -- | | Validity of month in constrained date. |
range : Interval<Date> | 0..1 | -- | | Interval of Dates specifying constraint |
timezone_validity : VALIDITY_KIND | 0..1 | -- | | Validity of timezone in constrained date. |
| Operations |
| Signature | Constraints | Documentation |
validity_is_range()
:
Boolean | | True if validity is in the form of a range; useful for developers to check which kind of constraint has been set. |
| Constraints |
| Name | Expression |
| validity_is_range | inv: validity_is_range = (range <> Void) |
| month_validity_optional | inv: month_validity = VALIDITY_KIND.optional implies
(day_validity = VALIDITY_KIND.optional or day_validity =
VALIDITY_KIND.disallowed) |
| month_validity_disallowed | inv: month_validity = {VALIDITY_KIND}.disallowed
implies day_validity = {VALIDITY_KIND}.disallowed |
Parent Package: primitive
Class C_PRIMITIVE{Abstract}
Direct Subclassifiers:
C_STRING, C_INTEGER, C_TIME, C_REAL, C_BOOLEAN, C_DATE, C_DURATION, C_DATE_TIME
| Operations |
| Signature | Constraints | Documentation |
assumed_value()
:
Any | | Value to be assumed if none sent in data |
default_value()
:
Any | | Generate a default value from this constraint object |
has_assumed_value()
:
Boolean | | True if there is an assumed value |
valid_value(a_value : Any)
:
Boolean |
pre: a_value <> Void | True if a_value is valid with respect to constraint expressed in concrete instance of this type. |
| Constraints |
| Name | Expression |
| Assumed_value_valid | inv: has_assumed_value implies valid_value(assumed_value) |
primitive
Enumeration VALIDITY_KIND
| Constraints |
| Name | Expression |
| Validity | inv: valid_validity(value) |
Parent Package: archetype
Package :: ontology
All linguistic and terminological entities in an archetype are represented in the ontology part of an archetype, whose semantics are given in the Ontology package.
Parent Package: ontology
Class ARCHETYPE_ONTOLOGY
Local ontology of an archetype.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
constraint_codes : List<String> | 1 | -- | | List of all term codes in the ontology. These correspond to the "ac" codes in an ADL archetype, or equivalently, the CONSTRAINT_REF . reference values in the archetype definition. |
specialisation_depth : Integer | 1 | -- | | Specialisation depth of this archetype. Unspecialised archetypes have depth 0, with each additional level of specialisation adding 1 to the specialisation_depth. |
term_attribute_names : List<String> | 1 | -- | | List of `attribute' names in ontology terms, typically includes `text', `description', `provenance' etc. |
term_codes : List<String> | 1 | -- | | List of all term codes in the ontology. Most of these correspond to "at" codes in an ADL archetype, which are the node_ids on C_OBJECT descendants. There may be an extra one, if a different term is used as the overall archetype concept_code from that used as the node_id of the outermost C_OBJECT in the definition part. |
terminologies_available : Set<String> | 1 | -- | | List of terminologies to which term or constraint bindings exist in this terminology. |
| Operations |
| Signature | Constraints | Documentation |
constraint_binding(a_terminology : String, a_code : String)
:
String |
pre: has_terminology(a_terminology_id) and
constraint_codes.has(a_code) | Binding of constraint corresponding to a_code in target external terminology a_terminology_id , as a string, which is usually a formal query expression. |
constraint_definition(a_lang : String, a_code : String)
:
ARCHETYPE_TERM |
pre: has_language(a_lang) and
constraint_codes.has(a_code) post: is_set=not is_ordered and is_unique | Constraint definition for a code, in a specified language. |
has_language(a_lang : String)
:
Boolean | | True if language `a_lang' is present in archetype ontology. |
has_terminology(a_terminology : String)
:
Boolean |
pre: has_terminology(a_terminology_id) pre: has_terminology(a_terminology_id) and
term_codes.has(a_code) | True if terminology `a_terminology' is present in archetype ontology. |
term_binding(a_terminology : String, a_code : String)
:
CODE_PHRASE |
pre: has_terminology(a_terminology_id) and
term_codes.has(a_code) | Binding of term corresponding to a_code in target external terminology a_terminology_id as a CODE_PHRASE . |
term_definition(a_lang : String, a_code : String)
:
ARCHETYPE_TERM |
pre: has_language(a_lang) and
term_codes.has(a_code) | Term definition for a code, in a specified language. |
| Constraints |
| Name | Expression |
| term_bindings_exists | inv: term_bindings <> void |
| terminologies_available_exists | inv: terminologies_available <> void |
| term_attribute_names_valid | inv: term_attribute_names <> void and
term_attribute_names.has('text') and
term_attribute_names.has('description') |
| constraint_bindings_exists | inv: constraint_bindings <> void |
| parent_archetype_valid | inv: parent_archetype <> Void and
parent_archetype.description = Current |
| constraint_codes_exists | inv: constraint_codes <> void |
| concept_code_valid | inv: term_codes.has (concept_code) |
| term_codes_exists | inv: term_codes <> void |
Parent Package: ontology
Class ARCHETYPE_TERM
Representation of any coded entity (term or constraint) in the archetype ontology.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
code : String | 1 | -- | | Code of this term. |
items : Hash<String,String> | 1 | -- | | Hash of keys ("text", "description" etc) and corresponding values. |
| Constraints |
| Name | Expression |
| code_valid | inv: code <> void and not code.is_empty |
| keys_valid | inv: keys <> Void |
Parent Package: am
Package :: openehr_profile
Parent Package: openehr_profile
Package :: data_types
This data type specification constitutes the lowest level of technical specification of openEHR, and describes a set of types suitable for use in clinical and related information structures. In order for such types to exist, a set of primitive types is assumed, namely Integer, Real, Boolean, Character, String, List, Set, and Array. These have standard definitions in the OMG object model used in UML, OCL, and are available in almost all type systems. The exact assumptions are described in the openEHR Support Reference Model. A number of symbolic definitions (similar to constants in programming) are also described in the Support RM.
The data types described here are named with the class prefix “DV_”, and inherit from the class DATA_VALUE. They have two distinct uses in reference models. Firstly, they may be used as “data values” in reference model structures wherever the DATA_VALUE class appears, for example, in the EHR Reference Model via the ELEMENT.value attribute. Additionally, specific subtypes of the data types described here can also be used as attribute types in other classes in reference models, such as date/times, coded terms and so on. The difference is that in the former case, only subtypes of DATA_VALUE may be used, whilst in the latter case, other types may be used as well, from the assumed set of basic types.
Parent Package: data_types
Package :: basic
Parent Package: basic
Class TRANSITION
Definition of a state machine transition.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
action : String | 0..1 | -- | | Side-effect action to execute during the firing of this transition |
event : String | 1 | -- | | Event which fires this transition |
guard : String | 0..1 | -- | | Guard condition which must be true for this transition to fire |
| Constraints |
| Name | Expression |
| Action_valid | inv: action <> Void implies not action.is_empty
|
| Guard_valid | inv: guard <> Void implies not guard.is_empty
|
| Event_valid | inv: event <> Void and not event.is_empty
|
| Next_state_valid | inv: next_state <> Void |
Parent Package: basic
Class C_DV_STATE
C_DOMAIN_TYPE
| +--C_DV_STATE
Constrainer type for DV_STATE instances. The attribute c_value defines a state/event table which constrains the allowed values of the attribute value in a DV_STATE instance, as well as the order of transitions between values.
| Constraints |
| Name | Expression |
| c_value_exists | inv: value <> Void |
Parent Package: basic
Class STATE{Abstract}
Direct Subclassifiers:
NON_TERMINAL_STATE, TERMINAL_STATE
Abstract definition of one state in a state machine.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
name : String | 1 | -- | | name of this state |
| Constraints |
| Name | Expression |
| Name_valid | inv: name <> Void and not name.is_empty |
| Transitions_valid | inv: transitions <> Void and not transitions.is_empty |
Parent Package: basic
Class STATE_MACHINE
Definition of a state machine in terms of states, transition events and outputs, and
next states.
| Constraints |
| Name | Expression |
| States_valid | inv: states <> Void and not states.isempty |
Parent Package: basic
Class TERMINAL_STATE
STATE
| +--TERMINAL_STATE
Parent Package: basic
Class NON_TERMINAL_STATE
STATE
| +--NON_TERMINAL_STATE
Definition of a non-terminal state in a state machine, i.e. one that has transitions.
| Constraints |
| Name | Expression |
| Transitions_valid | inv: transitions <> Void and not transitions.is_empty |
Parent Package: data_types
Package :: quantity
Parent Package: quantity
Class C_QUANTITY_ITEM
Constrain instances of DV_QUANTITY.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
magnitude : Interval<Real> | 0..1 | -- | |
Constraint on the magnitude of the DV_QUANTITY.
|
precision : Interval<Integer> | 0..1 | -- | |
Constraint on the precision of the DV_QUANTITY.
A value of -1 means that precision is unconstrained.
|
units : String | 0..1 | -- | |
Constraint on the units of the DV_QUANTITY.
|
| Operations |
| Signature | Constraints | Documentation |
precision_unconstrained()
:
Boolean |
inv: units <> Void and not units.is_empty | True if no constraint on precision; True if precision = -1. |
| Constraints |
| Name | Expression |
| units_valid | inv: units<> Void and not units.is_empty |
Parent Package: quantity
Class C_DV_ORDINAL
C_DOMAIN_TYPE
| +--C_DV_ORDINAL
Class specifying constraints on instances of DV_ORDINAL. Custom constrainer type for instances of DV_ORDINAL.
| Constraints |
| Name | Expression |
| Items_valid | inv: not list.is_empty |
| Ordinals_valid | inv:items <> Void xor any_allowed |
Parent Package: quantity
Class C_DV_QUANTITY
C_DOMAIN_TYPE
| +--C_DV_QUANTITY
Constrain instances of DV_QUANTITY.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
property : CODE_PHRASE | 0..1 | -- | | Optional constraint on units property |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| list : List<C_QUANTITY_ITEM> | 0..1 | 0..* ordered |
|
| list : Set<C_QUANTITY_ITEM> | 0..1 | 0..* | List of value/units pairs. |
| Constraints |
| Name | Expression |
| List_valid | inv: list <> Void implies not list.is_empty
|
| overall_validity | inv: (list <> Void or property <> Void)
xor any_allowed |
| property_valid | inv: property <> Void implies
terminology(Terminology_id_openehr)
.has_code_for_group_id
(Group_id_property, property)
|
Parent Package: data_types
Package :: text
Parent Package: text
Class C_CODE_PHRASE
C_DOMAIN_TYPE
| +--C_CODE_PHRASE
Express constraints on instances of CODE_PHRASE. The terminology_id attribute
may be specified on its own to indicate any term from a specified terminology;
the code_list attribute may be used to limit the codes to a specific list.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
code_list : List<String> | 0..1 | -- | | List of allowed codes; may be empty, meaning any code in the terminology may be used. |
| Operations |
| Signature | Constraints | Documentation |
any_allowed()
:
Boolean |
post: Result = terminology_id = Void
and code_list = Void | True if any CODE_PHRASE instance allowed. |
| Constraints |
| Name | Expression |
| Any_allowed_validity | inv: any_allowed xor terminology_id <> Void
|
| List_validity | inv: code_list <> Void implies (not code_list.is_empty and
terminology_id <> Void) |
Parent Package: am
Package :: template
Package :: assumed_types
This package provides models for common generic and container types not directly supported in UML.
Parent Package: assumed_types
Class List{Abstract}
Aggregate
| +--List
Ordered container that may contain duplicates.
| Operations |
| Signature | Constraints | Documentation |
first()
:
T | | Return first element. |
last()
:
T | | Return last element. |
| Constraints |
| Name | Expression |
| Last_validity | inv: not is_empty implies last <> Void |
| First_validity | inv: not is_empty implies first <> Void |
Parent Package: assumed_types
Class Set{Abstract}
Aggregate
| +--Set
Non-ordered conatiner that does not contain duplicates
Parent Package: assumed_types
Class Interval
Any
| +--Interval
Direct Subclassifiers:
DV_INTERVAL
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
lower : T | 1 | -- | | Lower bound. |
lower_included : Boolean | 1 | -- | | lower boundary value included in range if not lower_unbounded |
lower_unbounded : Boolean | 1 | -- | | lower boundary open (i.e. = -infinity) |
upper : T | 1 | -- | | Upper bound. |
upper_included : Boolean | 1 | -- | | upper boundary value included in range if not upper_unbounded |
upper_unbounded : Boolean | 1 | -- | | upper boundary open (i.e. = +infinity) |
| Constraints |
| Name | Expression |
| Limits_comparable | inv: (not upper_unbounded and not lower_unbounded) implies
lower.strictly_comparable_to(upper) |
| Limits_consistent | inv: (not upper_unbounded and not lower_unbounded) implies
lower <= upper
|
| Lower_included_valid | inv: lower_unbounded implies not lower_included |
| Upper_included_valid | inv: upper_unbounded implies not upper_included |
Parent Package: assumed_types
Class Hash{Abstract}
Aggregate
| +--Hash
Type representing a keyed table of values. T is the value type, and U the type of
the keys.
| Operations |
| Signature | Constraints | Documentation |
has_key(a_key : U)
:
Boolean | | Test for membership of a key |
item(a_key : T)
:
T | | Return item for key ‘a_key’. Equivalent to ISO 11404 fetch operation. |
Parent Package: assumed_types
Class Aggregate{Abstract}
Any
| +--Aggregate
Direct Subclassifiers:
Set, String, List, Hash, Array
Abstract parent of of the aggregate types List, Set, Array
and Hash.
| Operations |
| Signature | Constraints | Documentation |
count()
:
Integer | | Number of items in container |
has(v : T)
:
Boolean | | Test for membership of a value |
is_empty()
:
Boolean | | True if container is empty. |
Parent Package: assumed_types
Class Array{Abstract}
Aggregate
| +--Array
Container whose storage is assumed to be contiguous
Parent Package: assumed_types
Class ISO8601_DATE
TIME_DEFINITIONS
| +--ISO8601_DATE
Implementing Classifiers:
DV_DATE
Represents an absolute point in time, as measured on the Gregorian calendar, and specified only to the day.
| Operations |
| Signature | Constraints | Documentation |
as_string()
:
String | |
ISO8601 string for date, in format YYYYMMDD or
YYYY-MM-DD, or a partial invariant. See
valid_iso8601_date for validity.
|
day()
:
Integer | | returns the day of the momth, derived from the string value |
day_unknown()
:
Boolean | | Indicates whether day in month is unknown.
If so, and month is known, the date is of the form “YYYY-MM” or “YYYYMM”. |
infix('<' : Character, other : ISO8601_DATE)
:
Boolean | | Arithmetic comparison with other date. True if this date is closer to the origin than other. |
is_extended()
:
Boolean | | True if this date uses ‘-’ separators. |
is_partial()
:
Boolean | | True if this date is partial, i.e. if day or more is missing. |
month()
:
Integer |
pre: not month_unknown | returns the month in year derived from the string value |
month_unknown()
:
Boolean | | Indicates whether month in year is unknown. If so, the date is of the form “YYYY”. |
valid_iso8601_date(s : String)
:
Boolean | |
String is a valid ISO 8601 date, i.e. takes the complete
form:
•YYYYMMDD
or the extended form:
•YYYY-MM-DD
or one of the partial forms:
•YYYYMM
•YYYY
or the equivalent extended form:
•YYYY-MM
Where:
•YYYY is the string form of any positive number in the
range “0000” - “9999”
(zero-filled to four digits)
•MM is “01” - “12” (zero-filled to two
digits)
•DD is “01” - “31” (zero-filled to two
digits)
The combinations of YYYY, MM, DD numbers ust be correct with
respect to the Gregorian calendar.
|
year()
:
Integer | | returns the year derived from the string value |
| Constraints |
| Name | Expression |
| Hour_valid | inv: valid_hour(hour, minute, second) |
| Second_valid | inv: not second_unknown implies valid_second(second) |
| Partial_validity | inv:minute_unknown implies second_unknown |
| Year_valid | inv: valid_year(year) |
Parent Package: assumed_types
Class ISO8601_TIME
TIME_DEFINITIONS
| +--ISO8601_TIME
Implementing Classifiers:
DV_TIME
Represents an absolute point in time from an origin usually interpreted as meaning the start of the current day, specified to the second.
| Operations |
| Signature | Constraints | Documentation |
as_string()
:
String | |
ISO8601 string for time, i.e. in form:
hhmmss[,sss][Z|±hhmm] or the extended form:
hh:mm:ss[,sss][Z|±hhmm], or a partial invariant.
See valid_iso8601_time for validity.
|
fractional_second()
:
Double |
pre: not second_unknown | Fractional seconds (just the factional part). |
has_fractional_second()
:
Boolean | | True if the fractional_second part is signficant (i.e. even if = 0.0). |
hour()
:
Integer | | Hour in day, in 24-hour time. |
infix('<' : Character, other : ISO8601_TIME)
:
Boolean | | Arithmetic comparison with other time. True if this date is closer to previous midnight than other. |
is_decimal_sign_comma()
:
Boolean | | True if this time has a decimal part indicated by ‘,’ (comma) rather than ‘.’ (period). |
is_extended()
:
Boolean | | True if this time uses ‘:’ separators. |
is_partial()
:
Boolean | | True if this date is partial, i.e. if seconds or more is missing. |
minute()
:
Integer |
pre: not minute_unknown | Minute in hour.
|
minute_unknown()
:
Boolean | | Indicates whether minute is unknown. If so, the time is of the form “hh”. |
second()
:
Integer |
pre: not second_unknown | Second in minute. |
second_unknown()
:
Boolean | | Indicates whether second is unknown. If so and month is known, the time is of the form
“hh:mm” or “hhmm”. |
timezone()
:
ISO8601_TIMEZONE | | Timezone; may be Void. |
valid_iso8601_time(s : String)
:
Boolean | |
String is a valid ISO 8601 date, i.e. takes the form:
•hhmmss[,sss][Z | ±hhmm]
or the extended form:
•hh:mm:ss[,sss][Z | ±hhmm]
or one of the partial forms:
•hhmm or hh
or the extended form:
•hh:mm
with an additional optional timezone indicator of:
•Z or ±hhmm
Where:
•hh is “00” - “24” (0-filled to two digits)
•mm is “00” - “59” (0-filled to two digits)
•ss is “00” - “60” (0-filled to two digits)
•sss is any numeric string, representing an
optional fractional second
•Z is a literal meaning UTC (modern
replacement for GMT), i.e. timezone +0000
•±hhmm, i.e. +hhmm or -hhmm, indicating
the timezone.
The only combination allowed when hh=24 is
“24:00:00”, meaning “end of the calendar day”
according to the standard.
|
| Constraints |
| Name | Expression |
| Hour_valid | inv: valid_hour(hour, minute, second) |
| Minute_valid | inv: not minute_unknown implies valid_minute(minute) |
| Second_valid | inv: not second_unknown implies valid_second(second) |
| Partial_validity | inv:minute_unknown implies second_unknown |
| Fractional_second_valid | inv: has_fractional_second implies (not second_unknown and valid_fractional_second(fractional_second)) |
Parent Package: assumed_types
Class ISO8601_DATE_TIME
TIME_DEFINITIONS
| +--ISO8601_DATE_TIME
Implementing Classifiers:
DV_DATE_TIME
| Operations |
| Signature | Constraints | Documentation |
as_string()
:
String |
post: valid_iso8601_date_time(Result) |
ISO8601 string for date/time, in format
YYYYMMDDThhmmss[,sss][Z | ±hhmm]
or in extended format
YYYY-MM-DDThh:mm:ss[,sss][Z |±hhmm]
or a partial variant; see valid_iso8601_date_time() below.
|
day()
:
Integer | | day in month |
day_unknown()
:
Boolean | | Indicates whether day in month is unknown. |
fractional_second()
:
Double | | fractional seconds |
has_fractional_second()
:
Boolean | | True if the fractional_second part is signficant (i.e. even if = 0.0). |
hour()
:
Integer | | hour in day |
hour_unknown()
:
Boolean | | Indicates whether hour in day is known. |
infix('<' : Character, other : ISO8601_DATE_TIME)
:
Boolean | | Arithmetic comparison with other date/time.
True if this date/time is closer to origin than other. |
is_decimal_sign_comma()
:
Boolean | | True if this time has a decimal part indicated by ‘,’ (comma) rather than ‘.’ (period). |
is_extended()
:
Boolean | | True if this date/time uses ‘-’, ‘:’ separators. |
is_partial()
:
Boolean | | True if this date is partial, i.e. if seconds or more is missing. |
minute()
:
Integer | | minute in hour |
minute_unknown()
:
Boolean | | Indicates whether minute in hour is known. |
month()
:
Integer | | month in year |
month_unknown()
:
Boolean | | Indicates whether month in year is unknown. |
second()
:
Integer | | second in minute |
second_unknown()
:
Boolean | | Indicates whether minute in hour is known. |
timezone()
:
ISO8601_TIMEZONE | | Timezone; may be Void. |
valid_fractional_second(fs : Double)
:
Boolean |
post: Result = (fs>= 0.0 and fs >1.0) | |
valid_iso8601_date_time(s : String)
:
Boolean | |
String is a valid ISO 8601 date-time, i.e.
takes the form:
•YYYYMMDDThhmmss[,sss][Z|±hhmm]
or the extended form:
•YYYY-MM-DDThh:mm:ss[,sss][Z|±hhmm]
or one of the partial forms:
•YYYYMMDDThhmm
•YYYYMMDDThh
or the equivalent extended forms:
•YYYY-MM-DDThh:mm
•YYYY-MM-DDThh
(meanings as in DV_DATE, DV_TIME) and
the values in each field are valid.
|
year()
:
Integer | | year |
| Constraints |
| Name | Expression |
| Partial_validity_minute | inv: minute_unknown implies second_unknown |
| Month_valid | inv: valid_month(month) |
| Partial_validity_hour | inv: not hour_unknown |
| Partial_validity_month | inv: not month_unknown |
| Second_valid | inv: not second_unknown implies valid_second(second) |
| Day_valid | inv: valid_day(year, month, day) |
| Year_valid | inv: valid_year(year) |
| Partial_validity_day | inv: not day_unknown |
| Fractional_second_valid | inv: has_fractional_second implies (not second_unknown and valid_fractional_second(fractional_second)) |
| Hour_valid | inv: valid_hour(hour, minute, second) |
| Minute_valid | inv: not minute_unknown implies valid_minute(minute) |
| Fractional_second_valid: | inv: has_fractional_second implies (not second_unknown
and valid_fractional_second(fractional_second)) |
| Partial_validity_year | inv: not month_unknown |
Parent Package: assumed_types
Class ISO8601_DURATION
TIME_DEFINITIONS
| +--ISO8601_DURATION
Implementing Classifiers:
DV_DURATION
| Operations |
| Signature | Constraints | Documentation |
as_string()
:
String | |
ISO8601 string for duration, in format
• P[nnY][nnM][nnW][nnD][T[nnH][nnM][nnS]]
|
days()
:
Integer | | number of 24 hour days |
fractional_second()
:
Double | | fractional seconds |
hours()
:
Integer | | number of 60 minute hours |
is_decimal_sign_comma()
:
Boolean | | True if this time has a decimal part indicated by ‘,’ (comma) rather than ‘.’ (period). |
minutes()
:
Integer | | number of 60 second minutes |
months()
:
Integer | | number of months of nominal 30 day length |
seconds()
:
Integer | | number of seconds |
valid_iso8601_duration(s : String)
:
Boolean | |
String is a valid ISO 8601 duration, i.e. takes the form:
•P[nnY][nnM][nnW][nnD][T[nnH][nnM][nnS]
Where each nn represents a number of years, months, etc. nnW
represents a number of 7-day weeks.
Note: allowing the W designator in the
same
expression as other designators is an
exception
to the published standard, but
necessary
in clinical information (typically for
representing
pregnancy duration).
|
weeks()
:
Integer | | number of 7 day weeks |
years()
:
Integer | | number of years of nominal 365-day length |
| Constraints |
| Name | Expression |
| months_valid | inv: months >= 0 |
| years_valid | inv: years >= 0 |
| hours_valid | inv: hours >= 0 |
| days_vlid | inv: days >= 0 |
| minutes_valid | inv: minutes >= 0 |
| fractional_second_valid | inv: fractional_seconds >= 0.0 and fractional_seconds < 1.0 |
| weeks_valid | inv: weeks >= 0 |
| seconds_valid | inv: seconds >= 0 |
Parent Package: assumed_types
Class TIME_DEFINITIONS
Any
| +--TIME_DEFINITIONS
Direct Subclassifiers:
ISO8601_DATE, ISO8601_DURATION, ISO8601_DATE_TIME, ISO8601_TIMEZONE, ISO8601_TIME
Implementing Classifiers:
DV_DURATION
Definitions for date/time classes. Note that the timezone limits are set by where
the international dateline is. Thus, time in New Zealand is quoted using +12:00,
not -12:00.
| Operations |
| Signature | Constraints | Documentation |
valid_day(y,m,d : Integer)
:
Boolean |
post: Result = (d>=1 and d<= Days_in_month(m,y)) | |
valid_hour(h,m,s : Integer)
:
Boolean |
post: Result=(h>=0 and h<Hours_in_day) or (h=Hours_in_day and m=0 and s=0) | |
valid_minute(m : Integer)
:
Boolean |
post: Result = (m>=0 and m<Minutes_in_hour) | |
valid_month(m : Integer)
:
Boolean | | |
valid_second(s : Integer)
:
Boolean | | |
valid_year(y : Integer)
:
Boolean |
post: Result=(y>=0) | True if v>=0 |
Parent Package: assumed_types
Class ISO8601_TIMEZONE
TIME_DEFINITIONS
| +--ISO8601_TIMEZONE
Parent Package: assumed_types
Class String
Aggregate
| +--String
| Operations |
| Signature | Constraints | Documentation |
as_integer()
:
Integer |
pre: is_integer | Return the integer corresponding to the integer value represented in this string. |
infix('+' : Character, other : String)
:
String | | Concatenation operator - causes ‘other’ to be appended to this string |
is_empty()
:
Boolean | | True if string is empty, i.e. equal to “”. |
is_integer()
:
Boolean | | True if string can be parsed as an integer. |
Package :: rm
Parent Package: rm
Package :: common
Parent Package: common
Package :: archetyped
Parent Package: archetyped
Class LOCATABLE{Abstract}
PATHABLE
| +--LOCATABLE
Direct Subclassifiers:
DATA_STRUCTURE, EVENT, COMPOSITION, FOLDER, CONTACT, ACTIVITY, EHR_STATUS, CAPABILITY, EHR_ACCESS, PARTY_RELATIONSHIP, PARTY_IDENTITY, PARTY, ADDRESS, CONTENT_ITEM
Root class of all information model classes that can be archetyped.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
archetype_node_id : String | 1 | -- | | Design-time archetype id of this node taken from its generating archetype; used to build archetype paths. Always in the form of an “at” code, e.g. “at0005”. This value enables a "standardised" name for this node to be generated, by referring to the generating archetype local ontology.
At an archetype root point, the value of this attribute is always the stringified form of the archetype_id found in the archetype_details object. |
name : DV_TEXT | 1 | -- | | Runtime name of this fragment, used to build runtime paths. This is the term provided via a clinical application or batch process to name this EHR construct: its retention in the EHR faithfully preserves the original label by which this entry was known to end users. |
uid : UID_BASED_ID | 0..1 | -- | | Optional globally unique object identifier for root points of archetyped structures. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| links : Set<LINK> | 0..1 | * | Links to other archetyped structures (data whose root object inherits from ARCHETYPED, such as ENTRY, SECTION and so on). Links may be to structures in other compositions. |
| archetype_details : ARCHETYPED | 0..1 | -- | Details of archetyping used on this node. |
| feeder_audit : Set<FEEDER_AUDIT> | 0..1 | 0..* | Audit trail from non-openEHR system of original commit of information forming the content of this node, or from a conversion gateway which has synthesised this node. |
| Operations |
| Signature | Constraints | Documentation |
concept()
:
DV_TEXT |
pre: is_archetype_root | Clinical concept of the archetype as a whole (= derived from the ‘archetype_node_id’ of the root node) |
is_archetype_root()
:
Boolean | | True if this node is the root of an archetyped structure. |
| Constraints |
| Name | Expression |
| Name_valid | inv: name <> Void |
| Archetype_node_id_valid | inv: archetype_node_id <> Void and not
archetype_node_id.is_empty |
| Links_valid | inv: links <> Void implies not links.empty |
| Archetyped_valid | inv: is_archetype_root xor archetype_details = Void |
Parent Package: archetyped
Class LINK
The LINK type defines a logical relationship between two items, such as two ENTRYs or an ENTRY and a COMPOSITION. Links can be used across compositions, and across EHRs. Links can potentially be used between interior (i.e. non-archetype root) nodes, although this probably should be prevented in archetypes. Multiple LINKs can be attached to the root object of any archetyped structure to give the effect of a 1->N link
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
meaning : DV_TEXT | 1 | -- | | Used to describe the relationship, usually in clinical terms, such as “in response to” (the relationship between test results and an order), “follow-up to” and so on. Such relationships
can represent any clinically meaningful connection between pieces of information.
Values for meaning include those described in Annex C, ENV 13606 pt 2 [11] under the categories of “generic”, “documenting and reporting”, “organisational”, “clinical”,
“circumstancial”, and “view management”. |
target : DV_EHR_URI | 1 | -- | | The logical “to” object in the link relation, as per the linguistic sense of the meaning attribute. |
type : DV_TEXT | 1 | -- | | The type attribute is used to indicate a clinical or domain-level meaning for the kind of link,
for example “problem” or “issue”. If type values are designed appropriately, they can be used
by the requestor of EHR extracts to categorise links which must be followed and which can be broken when the extract is created. |
| Constraints |
| Name | Expression |
| Meaning_valid | inv: meaning <> Void |
| Type_valid | inv: type <> Void |
| Target_valid | inv: target <> Void |
Parent Package: archetyped
Class FEEDER_AUDIT
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
feeder_system_item_ids : List<DV_IDENTIFIER> | 0..1 | -- | | Identifiers used for the item in the feeder system, where the feeder system is distinct from the originating system. |
original_content : DV_ENCAPSULATED | 0..1 | -- | | Optional inline inclusion of or reference to original content corresponding to the openEHR content at this node. Typically a URI reference to a document or message in a persistent store associated with the EHR. |
originating_system_item_ids : List<DV_IDENTIFIER> | 0..1 | -- | | Identifiers used for the item in the originating system, e.g. filler and placer ids. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| originating_system_audit : FEEDER_AUDIT_DETAILS | 1 | -- | Any audit information for the information item from the originating system. |
| feeder_system_audit : FEEDER_AUDIT_DETAILS | 0..1 | -- | Any audit information for the information item from the feeder system, if different from the originating system. |
| Constraints |
| Name | Expression |
| Originating_system_audit_valid | inv: originating_system_audit <> Void |
Parent Package: archetyped
Class ARCHETYPED
Archetypes act as the configuration basis for the particular structures of instances defined by the reference model. To enable archetypes to be used to create valid data, key classes in the reference model act as “root” points for archetyping; accordingly, these classes have the archetype_details attribute set. An instance of the class ARCHETYPED contains the relevant archetype identification information, allowing generating archetypes to be matched up with data instances
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
archetype_id : ARCHETYPE_ID | 1 | -- | | Globally unique archetype identifier. |
rm_version : String | 1 | -- | | Version of the openEHR reference model used to create this object. Expressed in terms of the release version string, e.g. “1.0”, “1.2.4”. |
template_id : TEMPLATE_ID | 0..1 | -- | | Globally unique template identifier, if a template was active at this point in the structure.
Normally, a template would only be used at the top of a top-level structure, but the possibility
exists for templates at lower levels. |
| Constraints |
| Name | Expression |
| rm_version_valid | inv: rm_version <> Void and not rm_version.is_empty |
| archetype_id_valid | inv: archetype_id <> Void |
Parent Package: archetyped
Class FEEDER_AUDIT_DETAILS
Audit details for any system in a feeder system chain. Audit details here means the general notion of who/where/when the information item to which the audit is attached was created. None of the attributes is defined as mandatory, however, in different scenarios, various combinations of attributes will usually be mandatory. This can be controlled by specifying feeder audit details in legacy archetypes.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
location : PARTY_IDENTIFIED | 0..1 | -- | | Identifier of the particular site/facility within an organisation which handled the item. For
computability, this identifier needs to be e.g. a PKI identifier which can be included in the identifier list of the PARTY_IDENTIFIED object. |
provider : PARTY_IDENTIFIED | 0..1 | -- | | Optional provider(s) who created, committed, forwarded or otherwise handled the item. |
subject : PARTY_PROXY | 0..1 | -- | | Identifiers for subject of the received information item. |
system_id : String | 1 | -- | | Identifier of the system which handled the information item. |
time : DV_DATE_TIME | 0..1 | -- | | Time of handling the item. For an originating system, this will be time of creation, for an intermediate feeder system, this will be a time of accession or other time of handling, where
available. |
version_id : String | 0..1 | -- | | Any identifier used in the system such as “interim”, “final”, or numeric versions if available. |
| Constraints |
| Name | Expression |
| System_id_valid | inv: system_id <> Void and not system_id.is_empty |
Parent Package: archetyped
Class PATHABLE{Abstract}
Direct Subclassifiers:
EVENT_CONTEXT, ISM_TRANSITION, LOCATABLE, INSTRUCTION_DETAILS
Abstract parent of all classes whose instances are reachable by paths, and which know how to locate child object by paths. The parent feature may be implemented as a function or attribute.
| Operations |
| Signature | Constraints | Documentation |
item_at_path(a_path : String)
:
Any |
post: Result <> Void pre: path <>Void and
valid_path(a_path) | The item at a path (relative to this item); only valid for unique paths, i.e. paths that resolve to a single item. |
items_at_path(a_path : String)
:
List<Any> |
pre: path <>Void and not
path_unique(a_path) post: Result <> Void | List of items corresponding to a non-unique path
path. |
parent()
:
PATHABLE | | Parent of this node in compositional hierarchy. |
path_exists(a_path : String)
:
Boolean | | True if the path exists in the data with respect to the current item. |
path_of_item(a_loc : PATHABLE)
:
String |
pre: an_item <> Void | The path to an item relative to the root of this archetyped structure. |
path_unique(a_path : String)
:
Boolean |
pre: a_path <> Void and path_exists(a_path) | True if the path corresponds to a single item in the data. |
Parent Package: common
Package :: change_control
In various openEHR reference models, the semantics of formal change control are required. There are two architectural aspects of managing changes to data.
The first is the concept of a complex information object, being versioned in time, meaning that its creation and all subsequent modifications cause new “versions” to be created, rather than literally overwriting the existing data. Each version includes an audit trail, typically containing the dentity of a user, the date/time of the change, and a reason for the change.
The second aspect recognises that repositories are made up of complex information objects, and that changes are not in fact just made to individual objects, but to the respository itself. Any change by a user may change more than one versioned object in the repository, and the set of such changes - a “change-set” - constitutes the logical unit of change to the repository, taking it from one valid state to the next.
Parent Package: change_control
Class VERSIONED_OBJECT
Version control abstraction, defining semantics for versioning one complex object.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
owner_id : OBJECT_REF | 1 | -- | | Reference to object to which this versioned repository belongs, e.g. the id of the containing EHR. |
time_created : DV_DATE_TIME | 1 | -- | | Time of initial creation of this versioned object. |
uid : HIER_OBJECT_ID | 1 | -- | | Unique identifier of this version repository. |
| Operations |
| Signature | Constraints | Documentation |
all_version_ids()
:
List<OBJECT_VERSION_ID> | | Return a list of ids of all versions in this object. |
all_versions(T)
:
List<VERSION> | | Return a list of all versions in this object. |
commit_attestation()
:
|
pre: an_attestation <> Void and
has_version_id(a_ver_id) | Add a new attestation to a specified original version. Attestations can only be added to Original versions.
Parameters:
(an_attestation: ATTESTATION;
a_ver_id: OBJECT_VERSION_ID;
signing_key: String)
require
Attestation_valid: an_attestation /= Void
Version_id_valid: has_version_id(a_ver_id)
and is_original_version(a_ver_id) |
commit _imported_version()
:
| | Add a new imported version.
Details of version id etc come from the ORIGINAL_VERSION being committed.
Parameters:
(a_contribution_id: OBJECT_REF;
an_audit: AUDIT_DETAILS;
a_version: ORIGINAL_VERSION)
require
Contribution_valid: a_contribution /= Void
audit_valid: an_audit /= Void
Version_valid: a_version /= Void |
commit _original_merged_version()
:
| | Add a new original merged version. This commit function adds a parameter containing the ids of other versions merged into the current one.
Parameters:
(a_contribution_id: OBJECT_REF;
a_new_version_uid, a_preceding_version_uid:
OBJECT_VERSION_ID;
an_audit: AUDIT_DETAILS;
a_lifecycle_state: DV_CODED_TEXT;
a_data: T;
an_other_input_uids:
Set;
signing_key: String)
require
Contribution_valid: a_contribution /= Void
New_version_valid: a_new_version_uid /= Void
Preceding_version_id_valid:
all_version_ids.has(a_preceding_version_uid) or
else version_count = 0
audit_valid: an_audit /= Void
data_valid: a_version_data /= Void
lifecycle_state_valid: a_lifecycle_state /= Void
Merge_input_ids_valid: an_other_input_uids /=
Void |
commit_original_version()
:
| | Add a new original version.
Parameters:
(a_contribution: OBJECT_REF;
a_new_version_uid, a_preceding_version_uid:
OBJECT_VERSION_ID;
an_audit: AUDIT_DETAILS;
a_lifecycle_state: DV_CODED_TEXT;
a_data: T;
signing_key: String)
require
Contribution_valid: a_contribution /= Void
New_version_valid: a_new_version_uid /= Void
Preceding_version_uid_valid:
all_version_ids.has(a_preceding_version_uid) or
else version_count = 0
audit_valid: an_audit /= Void
data_valid: a_version_data /= Void
lifecycle_state_valid: a_lifecycle_state /= Void
|
has_version_at_time(a_time : DV_DATE_TIME)
:
Boolean |
pre: a_time <> Void | True if a version for time ‘a_time’ exists. |
has_version_id(a_ver_id : OBJECT_VERSION_ID)
:
Boolean |
pre: a_ver_id <> Void | True if a version with a_ver_id exists. |
is_original_version(a_ver_id : OBJECT_VERSION_ID)
:
Boolean |
pre: a_ver_id <> Void and has_version_id(a_ver_id) | True if version with an id is an ORIGINAL_VERSION. |
latest_trunk_version()
:
VERSION | | Return the most recently added trunk version. |
latest_version()
:
VERSION | | Return the most recently added version (i.e. on trunk or any branch). |
lifecycle_state()
:
DV_CODED_TEXT |
post: Result = latest_trunk_version.lifecycle_state
| Return the lifecycle state from the latest trunk version.
Useful for determining if the version container is logically deleted. |
revision_history()
:
REVISION_HISTORY | | History of all audits and attestations in this versioned repository. |
version_at_time(a_time : DV_DATE_TIME)
:
VERSION |
pre: has_version_at_time(a_time) | Return the version for time ‘a_time’. |
version_count()
:
Integer | | Return the total number of versions in this object |
version_with_id(a_ver_id : OBJECT_VERSION_ID)
:
OBJECT_VERSION_ID |
pre: has_version_id(a_ver_id) | Return the version with id ‘a_ver_id’. |
| Constraints |
| Name | Expression |
| owner_id_valid | inv: owner_id <> Void |
| all_versions_valid | inv: all_versions <> Void and all_versions.count =
version_count |
| version_count_valid | inv: version_count >= 1 |
| uid_valid | inv: uid <> Void |
| latest_version_valid | inv: latest_version <> Void |
| all_version_ids_valid | inv: all_version_ids <>Void and all_version_ids.count =
version_count |
| revision_history_valid | inv: revision_history <> Void |
| time_created_valid | inv: time_created <> Void |
Parent Package: change_control
Class CONTRIBUTION
Documents a contribution of one or more versions added to a change-controlled repository.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
uid : HIER_OBJECT_ID | 1 | -- | | Unique identifier for this contribution. |
versions : List<OBJECT_REF> | 1 | -- | | Set of references to versions causing changes to this EHR. Each contribution contains a list of versions, which may include paths pointing to any number of VERSIONABLE items, i.e. items of type COMPOSITION and FOLDER. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| audit : AUDIT_DETAILS | 1 | -- | Audit trail corresponding to the committal of this Contribution. |
| Constraints |
| Name | Expression |
| Versions_valid | inv: versions <> Void and not versions.is_empty |
| Description_valid | inv: audit.description <> Void |
| audit_validmed2 | inv: audit <> Void |
| uid_valid | inv: uid <> Void |
Parent Package: change_control
Class VERSION{Abstract}
Direct Subclassifiers:
ORIGINAL_VERSION, IMPORTED_VERSION, MERGED_VERSION
One version within a Version container, containing data, create and commit audit trails, and optional attestations.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
contribution : OBJECT_REF | 1 | -- | | Contribution in which this version was added. |
signature : String | 0..1 | -- | | OpenPGP digital signature or digest of content committed in this Version. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| commit_audit : AUDIT_DETAILS | 1 | -- | Audit trail corresponding to the committal of this version to the VERSION_REPOSITORY where it is currently located. |
| attestations : Set<ATTESTATION> | 0..1 | 0..* | Set of attestations relating to this version. |
| data : T | 0..1 | -- | The data being versioned. |
| Constraints |
| Name | Expression |
| Contribution_valid | inv: contribution <> Void and contribution.type.is_equal('CONTRIBUTION') |
| Data_valid | inv: data <> Void |
| Uid_valid | inv: uid <> Void |
| Owner_id_valid | inv: owner_id <> Void and
owner_id.value.is_equal(uid.object_id.value) |
| Lifecycle_state_valid | inv: lifecycle_state <> Void and terminology(
Term_id_openehr).
codes_for_group_name(Group_id_version_lifecycle_state,
'en').has(lifecycle_state.defining_code) |
| Commit_audit_valid | inv: commit_audit <> Void |
| Create_audit_valid | inv: create_audit <> Void and create_audit = commit_audit |
| Preceding_version_uid_validity | inv: uid.version_tree_id.is_first xor preceding_version_uid <> Void |
Parent Package: change_control
Class MERGED_VERSION
VERSION
| +--MERGED_VERSION
Merged Versions, recording the list of input versions to the merge in addition to standard Version attributes.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
input_version_ids : Set<OBJECT_VERSION_ID> | 0..1 | -- | | Identifiers of the Versions used as input into this merged version. There is no guarantee that the identifiers of all content Versions are included here. |
| Constraints |
| Name | Expression |
| Input_version_ids_valid | inv: input_version_ids <> Void and not
input_version_ids.is_empty |
Parent Package: change_control
Class IMPORTED_VERSION
VERSION
| +--IMPORTED_VERSION
Versionable objects that have been copied from another location and imported into a local version container.
| Constraints |
| Name | Expression |
| Original_create_audit_valid | inv: original_create_audit <> Void |
| Create_audit_valid | inv: create_audit <> Void and create_audit =original_create_audit |
Parent Package: change_control
Class ORIGINAL_VERSION
VERSION
| +--ORIGINAL_VERSION
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
lifecycle_state : DV_CODED_TEXT | 1 | -- | | Lifecycle state of the content item in this version. |
preceding_version_uid : OBJECT_VERSION_ID | 1 | -- | | Unique identifier of the version of which this version is a modification; Void if this is the first version. |
uid : OBJECT_VERSION_ID | 1 | -- | | Unique identifier of this version, containing owner_id, version_tree_id and creating_system_id. |
Parent Package: common
Package :: directory
The directory package provides a simple abstraction of a versioned folder structure. The VERSIONED_FOLDER class is the binding of VERSIONED_OBJECT to FOLDER, i.e. it is a VERSIONED_OBJECT.
This means that each of its versions is a FOLDER structure. It provides a means of versioning FOLDER structures over time, which is useful in the EHR, Demographics service or anywhere else where Folders are used to group things.
Parent Package: directory
Class VERSIONED_FOLDER
Parent Package: directory
Class FOLDER
LOCATABLE
| +--FOLDER
The concept of a named folder.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
items : List<OBJECT_REF> | 0..1 | -- | | The list of references to other (usually) versioned objects logically in this folder. |
| Constraints |
| Name | Expression |
| Folders_valid | inv: folders <> Void implies not folders.empty |
Parent Package: common
Package :: generic
Parent Package: generic
Class PARTICIPATION
Model of a participation of a Party (any Actor or Role) in an activity.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
function : DV_TEXT | 1 | -- | | The function of the Party in this participation (note that a given party might participate in more than one way in a particular activity). This attribute should be coded, but cannot be limited to the HL7v3:ParticipationFunction vocabulary, since it is too limited and hospital-oriented. |
mode : DV_CODED_TEXT | 1 | -- | | The mode of the performer / activity interaction, e.g. present, by telephone, by email etc. |
time : DV_INTERVAL<DV_DATE_TIME> | 0..1 | -- | | The time interval during which the participation took place, if it is used in an observational context (i.e. recording facts about the past); or the intended time interval of the participation when used in future contexts, such as EHR Instructions. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| performer : PARTY_REF | 1 | -- |
|
| performer : PARTY_PROXY | 1 | -- | The id and possibly demographic system link of the party participating in the activity. |
| Constraints |
| Name | Expression |
| Performer_valid | inv: performer <> Void |
| Mode_valid | inv: mode <> Void and terminology(Terminology_id_openehr).
has_code_for_group_id(Group_id_participation_mode, mode.defining_code) |
| Function_valid | inv: function <> Void and
function.generating_type.is_equal('DV_CODED_TEXT') implies
terminology(Terminology_id_openehr).
has_code_for_group_id(Group_id_participation_function, function.
defining_code) |
Parent Package: generic
Class REVISION_HISTORY
Defines the notion of a revision history of audit items, each associated with the version for which that audit was committed.
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| items : List<REVISION_HISTORY_ITEM> | 0..1 | * ordered | The items in this history. |
| Operations |
| Signature | Constraints | Documentation |
most_recent_version()
:
String |
post: Result.is_equal(items.last.version_id.value) | The version id of the most recent item, as a String. |
most_recent_version_time_committed()
:
String |
post: Result.is_equal(items.last.audits.first.time_committed.value) | The commit date/time of the most recent item, as a String. |
Parent Package: generic
Class REVISION_HISTORY_ITEM
An entry in a revision history, corresponding to a version from a versioned container
Consists of AUDIT_DETAILS instances with revision identifier of the revision to which the AUDIT_DETAILS intance belongs.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
version_id : OBJECT_VERSION_ID | 1 | -- | | Version identifier for this revision. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| audits : Set<AUDIT_DETAILS> | 1 | 1..* | The audits for this revision; there will always be at least one commit audit (which may itself be an ATTESTATION), there may also be further attestations. |
| Constraints |
| Name | Expression |
| Version_id_valid | inv: version_id <> Void |
| Audit_valid | inv: audit <> Void and not audits.is_empty |
Parent Package: generic
Class PARTY_PROXY{Abstract}
Direct Subclassifiers:
PARTY_IDENTIFIED, PARTY_SELF
Abstract concept of a proxy description of a party, including an optional link to
data for this party in a demographic or other identity management system.
Subtyped into PARTY_IDENTIFIED and PARTY_SELF.
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| external_ref : PARTY_REF | 0..1 | -- | Optional reference to more detailed demographic or identification information for this party, in an external system. |
Parent Package: generic
Class PARTY_SELF
PARTY_PROXY
| +--PARTY_SELF
Party proxy representing the subject of the record.
Parent Package: generic
Class PARTY_IDENTIFIED
PARTY_PROXY
| +--PARTY_IDENTIFIED
Direct Subclassifiers:
PARTY_RELATED
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
identifiers : List<DV_IDENTIFIER> | 0..1 | -- | | One or more formal identifiers (possibly computable). |
name : String | 0..1 | -- | | Optional human-readable name (in String form). |
Parent Package: generic
Class PARTY_RELATED
PARTY_IDENTIFIED
| +--PARTY_RELATED
Relationship of subject of this ENTRY to the subject of the record. May be coded. If it is the atient, coded as “self”.
| Constraints |
| Name | Expression |
| Relationship_valid | inv: relationship <> Void and
terminology(Terminology_id_openehr).
has_code_for_group_id(Group_id_subject_relationship, relationship.
defining_code) |
Parent Package: generic
Class ATTESTATION
AUDIT_DETAILS
| +--ATTESTATION
Record an attestation of a party (the committer) to item(s) of record content. The type of attestation is
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
attested_view : DV_MULTIMEDIA | 1 | -- | | Optional visual representation of content attested e.g. screen image. |
is_pending : Boolean | 1 | -- | | True if this attestation is outstanding; False means it has been completed. |
items : Set<DV_EHR_URI> | 0..1 | -- | | Items attested, expressed as fully qualified runtime paths to the items in question.
Although not recommended, these may include fine-grained items which have been attested in some other system. Otherwise it is assumed to be for the entire VERSION with which it is associated. |
proof : String | 0..1 | -- | | Proof of attestation. |
reason : DV_TEXT | 1 | -- | | Reason of this attestation. Optionally coded by the openEHR Terminology group “attestation reason”; includes values like “authorisation”, “witness” etc. |
| Constraints |
| Name | Expression |
| Reason_valid | inv: reason <> Void and (reason.
generating_type.is_equal('DV_CODED_TEXT') implies terminology(Terminology_id_openehr).has_code_for_group_id
(Group_id_attestation_reason, reason.defining_code)) |
| Items_valid | inv: items <> Void implies not items.is_empty |
Parent Package: generic
Class AUDIT_DETAILS
Direct Subclassifiers:
ATTESTATION
The set of attributes required to document the committal of an information item to
a repository.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
change_type : DV_CODED_TEXT | 1 | -- | | Type of change. Coded using the openEHR Terminology “audit change type” group. |
description : DV_TEXT | 0..1 | -- | | Reason for committal. |
system_id : String | 1 | -- | | Identity of the system where the change was committed. Ideally this is a machine- and human-processable identifier, but it may not be. |
time_committed : DV_DATE_TIME | 1 | -- | | Time of committal of the item. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| committer : PARTY_PROXY | 1 | -- | Identity and optional reference into identity management service, of user who committed the item. |
| Constraints |
| Name | Expression |
| Committer_valid | inv: committer <> Void |
| Time_committed_valid | inv: time_committed <> Void |
| System_id_valid | inv: system_id <> Void and not system_id.is_empty |
| Change_type_valid | inv: change_type<> Void and
terminology(Terminology_id_openehr).
has_code_for_group_id(Group_id_audit_change_type,
change_type.defining_code) |
Parent Package: common
Package :: resource
The common.resource package defines the structure and semantics of the general notion of an online resource which has been created by a human author, and consequently for which natural language is a factor.
Parent Package: resource
Class TRANSLATION_DETAILS
Class providing details of a natural language translation.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
accreditation : String | 1 | -- | | Accreditation of translator, usually a national translator’s association id |
author : Hash<String,String> | 1 | -- | | Translator name and other demographic details |
language : CODE_PHRASE | 1 | -- | | Language of translation |
other_details : Hash<String,String> | 0..1 | -- | | Any other meta-data |
| Constraints |
| Name | Expression |
| Author_valid | inv: author <> Void |
| Language_valid | inv: language <> Void and code_set('languages').has(language) |
Parent Package: resource
Class RESOURCE_DESCRIPTION
Defines the descriptive meta-data of a resource.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
lifecycle_state : String | 1 | -- | | Lifecycle state of the resource, typically including states such as: initial, submitted, experimental, awaiting_approval, approved, superseded, obsolete. |
original_author : Hash<String,String> | 1 | -- | | Original author of this resource, with all relevant details, including organisation. |
other_contributors : List<String> | 0..1 | -- | | Other contributors to the resource, probably listed in “name ” form. |
other_details : Hash<String,String> | 0..1 | -- | | Additional non language-senstive resource meta-data, as a list of name/value pairs. |
resource_package_uri : String | 0..1 | -- | | URI of package to which this resource belongs. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| details : Set<RESOURCE_DESCRIPTION_ITEM> | 0..1 | * | Details of all parts of resource description that are natural language-dependent. |
| parent_resource : AUTHORED_RESOURCE | 0..1 | -- | Reference to owning resource. |
| Constraints |
| Name | Expression |
| Details_valid | inv: details <> Void and not details.is_empty |
| Parent_resource_valid | inv: parent_resource <> Void implies
parent_resource.description = Current |
| Original_author_valid | inv: original_author <> Void and not
original_author.is_empty |
| Language_valid | inv: details.for_all (d |
parent_resource.languages_available.has(d.language)) |
| Lifecycle_state_valided2 | inv: lifecycle_state <> Void and not
lifecycle_state.is_empty |
Parent Package: resource
Class AUTHORED_RESOURCE{Abstract}
Direct Subclassifiers:
ARCHETYPE
Abstract idea of an online resource created by a human author.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
is_controlled : Boolean | 0..1 | -- | | True if this resource is under any kind of change control (even file copying), in which case revision history is created. |
original_language : CODE_PHRASE | 1 | -- | | Language in which this resource was initially authored. Although there is no language primacy
of resources overall, the language of original authoring is required to ensure natural language translations can preserve quality. Language is relevant in both the description and ontology sections. |
translations : Hash<TRANSLATION_DETAILS, String> | 0..1 | -- | | List of details for each natural translation made of this resource, keyed by language. For each translation listed here, there must be corresponding sections in all language-dependent parts of the resource. The original_language does not appear in this list. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| revision_history : REVISION_HISTORY | 0..1 | -- | The revision history of the resource. Only required if is_controlled = True (avoids large revision histories for informal or private editing situations). |
| description : RESOURCE_DESCRIPTION | 0..1 | -- | Description and lifecycle information of the resource. |
| Operations |
| Signature | Constraints | Documentation |
current_revision()
:
String |
post: Result = revision_history.most_recent_version | Most recent revision in revision_history if is_controlled else “(uncontrolled)”. |
languages_available()
:
Set<String> | | Total set of languages available in this resource, derived from original_language and translations. |
| Constraints |
| Name | Expression |
| Revision_history_valid | inv: is_controlled xor revision_history = Void |
| Current_revision_valid | inv: current_revision <> Void and not is_controlled implies current_revision.is_equal('(uncontrolled)') |
| Original_language_valid | inv: original_language <> void and
code_set(Code_set_id_languages).has_code(original_language.as_string) |
| Languages_available_valid | inv: languages_available <> Void and
languages_available.has(original_language) |
| Translations_valid | inv: translations <> Void implies (not translations.is_empty and not translations.has(orginal_language.code_string)) |
| Description_valid | inv: translations <> Void implies (description.details.for_all(d | translations.has_key(d.language.code_string))) |
Parent Package: resource
Class RESOURCE_DESCRIPTION_ITEM
Language-specific detail of resource description. When a resource is translated for use in another language environment, each RESOURCE_DESCRIPTION_ITEM needs to be copied and translated into the new language.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
copyright : String | 0..1 | -- | | Optional copyright statement for the resource as a knowledge resource. |
keywords : List<String> | 0..1 | -- | | Keywords which characterise this resource, used e.g. for indexing and searching. |
language : CODE_PHRASE | 1 | -- | | The localised language in which the items in this description item are written. Coded from openEHR Code Set “languages”. |
misuse : String | 0..1 | -- | | Description of any misuses of the resource, i.e. contexts in which it should not be used. |
original_resource_uri : Hash<String,String> | 0..1 | -- | | URIs of original clinical document(s) or description of which resource is a formalisation, in the language of this description item; keyed by meaning. |
other_details : Hash<String,String> | 0..1 | -- | | Additional language-senstive resource metadata, as a list of name/value pairs. |
purpose : String | 1 | -- | | Purpose of the resource. |
use : String | 0..1 | -- | | Description of the uses of the resource, i.e. contexts in which it could be used. |
| Constraints |
| Name | Expression |
| copyright_valid | inv: copyright <> Void implies not copyright.is_empty |
| misuse_valid | inv: misuse <> Void implies not misuse.is_empty |
| use_valid | inv: use <> Void implies not use.is_empty |
| purpose_valid | inv: purpose <> Void and not purpose.is_empty |
| Language_valid | inv: language <> Void and code_set('languages').has(language) |
Parent Package: rm
Package :: composition
The Composition is the primary ‘data container’ in the openEHR EHR and is the root point of clinical content. Instances of the Composition class can be considered as self-standing data aggregations, or documents in a document-oriented system (similar to HL7 CDA Documents). The key information in a COMPOSITION is found in its content, context, and composer attributes. The majority of the use of paths in openEHR is likely to be within Compositions.
Parent Package: composition
Class COMPOSITION
LOCATABLE
| +--COMPOSITION
One version in a VERSIONED_COMPOSITION. A composition is considered the unit of modification of the record, the unit of transmission in record extracts, and the unit of attestation by authorising clinicians. In this latter sense, it may be considered equivalent to a signed document.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
category : DV_CODED_TEXT | 1 | -- | | Indicates what broad category this Composition is belogs to, e.g. “persistent” - of longitudinal validity, “event”, “process” etc. |
language : CODE_PHRASE | 1 | -- | | Mandatory indicator of the localised language in which this Entry is written. Coded from
openEHR Code Set “languages”. |
territory : CODE_PHRASE | 1 | -- | | Name of territory in which this Composition was written. Coded from openEHR “countries” code set, which is an expression of the ISO 3166 standard. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| context : EVENT_CONTEXT | 0..1 | -- | The clinical session context of this Composition, i.e. the contextual attributes of the clinical session. |
| content : Set<CONTENT_ITEM> | 0..1 | 0..* | The content of this Composition. |
| composer : PARTY_PROXY | 1 | -- | |
| Operations |
| Signature | Constraints | Documentation |
is_persistent()
:
Boolean | | True if category is a “persistent” type, False otherwise. Useful for finding Compositions in an EHR which are guaranteed to be of interest to most users. |
| Constraints |
| Name | Expression |
| Is_archetype_root | inv: is_archetype_root |
| Content_valid | inv: content <> Void implies not content.is_empty |
| Composer_valid | inv: composer <> Void |
| Territory_valid | inv: territory <> Void and
code_set(Code_set_id_countries).has_code(territory) |
| No_parent | inv: parent = Void |
| Is_persistent_validity | inv: is_persistent implies context = Void |
| Category_validity | inv: category <> Void and
terminology(Terminology_id_openehr).
has_code_for_group_id(Group_id_composition_category, category.
defining_code) |
| language_valid | inv: language <> Void and code_set(Code_set_id_languages).has_code(language)
|
Parent Package: composition
Class EVENT_CONTEXT
PATHABLE
| +--EVENT_CONTEXT
Documents the context information of a healthcare event involving the subject of care and the health system. The context information recorded here are independent of the attributes recorded in the version audit, which document the “system interaction” context, i.e. the context of a user interacting with the health record system. Healthcare events include patient contacts, and any other business activity, such as pathology investigations which take place on behalf of the patient.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
end_time : DV_DATE_TIME | 0..1 | -- | | Optional end time of the clinical session. |
location : String | 0..1 | -- | | The actual location where the session occurred, e.g. “microbiol lab 2”, “home”, “ward A3” and so on. |
other_context : ITEM_STRUCTURE | 0..1 | -- | | Other optional context which will be archetyped. |
setting : DV_CODED_TEXT | 1 | -- | | The setting in which the clinical session took place. Coded using the openEHR Terminology, “setting” group. |
start_time : DV_DATE_TIME | 1 | -- | | Start time of the clinical session or other kind of event during which a provider performs a service of any kind for the patient. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| health_care_facility : PARTY_REF | 0..1 | -- |
|
| composer : PARTY_REF | 1 | -- |
|
| participations : Set<PARTICIPATION> | 0..1 | 0..* | Parties involved in the healthcare event. These would normally include the physician(s) and often the patient (but not the latter if the clinical session is a pathology test for example). |
| health_care_facility : PARTY_IDENTIFIED | 0..1 | -- | The health care facility under whose care the event took place. This is the most specific workgroup or delivery unit within a care delivery enterprise that has an official identifier in the health system, and can be used to ensure medico-legal accountability. |
| Constraints |
| Name | Expression |
| setting_valid | inv: setting <> Void and Terminology(Terminology_id_openehr).has_code_for_group_id
(Group_id_setting, setting.defining_code) |
| participations_validity | inv: participations <> Void implies not participations.
is_empty |
| start_time_valid | inv: start_time <> Void |
| location_valid | inv: location <> Void implies not location.is_empty
|
Parent Package: composition
Package :: content
Parent Package: content
Class CONTENT_ITEM{Abstract}
LOCATABLE
| +--CONTENT_ITEM
Direct Subclassifiers:
SECTION, ENTRY, GENERIC_ENTRY
Abstract ancestor of all concrete content types.
Parent Package: content
Package :: entry
All information which is created in the openEHR health record is expressed as an instance of a class in the entry package, containing the ENTRY class and a number of descendants. An ENTRY instance is logically a single ‘clinical statement’, and may be a single short narrative phrase, but may also contain a significant amount of data, e.g. an entire microbiology result, a psychiatric examination, a complex prescription. In terms of actual content, the Entry classes are the most important in the openEHR EHR Information Model, since they define the semantics of all the ‘hard’ information in the record. They are intended to be achetyped, and in fact, archetypes for Entries make up the vast majority of important clinical archetypes defined.
Parent Package: entry
Class OBSERVATION
CARE_ENTRY
| +--OBSERVATION
Entry subtype for all clinical data in the past or present, i.e. which (by the time it is recorded) has already occurred. OBSERVATION data is expressed using the class HISTORY, which guarantees that it is situated in time.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
data : HISTORY | 1 | -- | | The data of this observation, in the form of a history of values which may be of any complexity. |
state : HISTORY | 0..1 | -- | | Optional recording of the state of subject of this observation during the observation process, in the form of a separate history of values which may be of any complexity. State may also be recorded within the History of the data attribute. |
Parent Package: entry
Class EVALUATION
ENTRY, CARE_ENTRY
| +--EVALUATION
Entry type for evaluation statements.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
data : ITEM_STRUCTURE | 1 | -- | | The data of this evaluation, in the form of a spatial data structure. |
Parent Package: entry
Class INSTRUCTION
CARE_ENTRY, ENTRY
| +--INSTRUCTION
Used to specify actions in the future. Enables simple and complex specifications
to be expressed, including in a fully-computable workflow form.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
expiry_time : DV_DATE_TIME | 0..1 | -- | | Optional expiry date/time to assist determination of when an Instruction can be assumed to have expired. This helps prevent false listing of Instructions as Active when they clearly must have been terminated in some way or other. |
narrative : DV_TEXT | 1 | -- | | Mandatory human-readable version of what the Instruction is about. |
wf_definition : DV_PARSABLE | 0..1 | -- | | Optional workflow engine executable expression of the Instruction. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| activities : Set<ACTIVITY> | 0..1 | * | List of all activities in Instruction. |
| Constraints |
| Name | Expression |
| Narrative_valid | inv: narrative <> Void |
| Activities_valid | inv: activities <> Void implies not activities.is_empty |
Parent Package: entry
Class ENTRY{Abstract}
CONTENT_ITEM
| +--ENTRY
Direct Subclassifiers:
CARE_ENTRY, EVALUATION, INSTRUCTION, ADMIN_ENTRY
The abstract parent of all ENTRY subtypes. An ENTRY is the root of a logical item of “hard” clinical information created in the “clinical statement” context, within a clinical session. There can be numerous such contexts in a clinical session. Observations and other Entry types only ever document information captured/created in the event documented by the enclosing Composition.
An ENTRY is also the minimal unit of information any query should return, since a whole ENTRY (including subparts) records spatial structure, timing information, and contextual information, as well as the subject and generator of the information.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
encoding : CODE_PHRASE | 1 | -- | | Name of character set in which text values in this Entry are encoded. Coded from openEHR Code Set “character sets”. |
language : CODE_PHRASE | 1 | -- | | Mandatory indicator of the localised language in which this Entry is written. Coded from
openEHR Code Set “languages”. |
other_participations : List<PARTICIPATION> | 0..1 | -- | | Other participations at ENTRY level. |
provider : PARTY_PROXY | 0..1 | -- | | Optional identification of provider of the informatoin in this ENTRY, which might be:
• the patient
• a patient agent, e.g. parent, guardian
• the clinician
• a device or software
Generally only used when the recorder needs to make it explicit. Otherwise, Composition
composer and other participants are assumed. |
subject : PARTY_PROXY | 1 | -- | | Id of human subject of this ENTRY, e.g.:
• organ donor
• foetus
• a family member
• another clinically relevant person. |
workflow_id : OBJECT_REF | 0..1 | -- | | Identifier of externally held workflow engine data for this workflow execution, for this subject of care. |
| Operations |
| Signature | Constraints | Documentation |
subject_is_self()
:
Boolean | | Returns True if this Entry is about the subject of the EHR, in which case the subject attribute
is of type PARTY_SELF. |
| Constraints |
| Name | Expression |
| Subject_validity | inv: subject_is_self implies subject.generating_type =
'PARTY_SELF' |
| Archetype_root_point | inv: is_archetype_root |
| Other_participations_valid | inv: other_participations <> Void implies not
other_participations.is_empty
|
| Language_valid | inv: language <> Void and code_set(Code_set_id_languages).has_code(language)
|
| Encoding_valid | inv: encoding <> Void and code_set(Code_set_id_character_sets).has_code(encoding)
|
Parent Package: entry
Class ADMIN_ENTRY
ENTRY
| +--ADMIN_ENTRY
Entry subtype for administrative information, i.e. information about setting up the clinical process, but not itself clinically relevant. Archetypes will define contained information.
Parent Package: entry
Class CARE_ENTRY{Abstract}
ENTRY
| +--CARE_ENTRY
Direct Subclassifiers:
INSTRUCTION, ACTION, OBSERVATION, EVALUATION
The abstract parent of all clinical ENTRY subtypes. A CARE_ENTRY defines protocol and guideline attributes for all clinical Entry subtypes.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
guideline_id : OBJECT_REF | 0..1 | -- | | Optional external identifier of guideline creating this action if relevant |
protocol : ITEM_STRUCTURE | 0..1 | -- | | Description of the method (i.e. how) the information in this entry was arrived at. For OBSERVATIONs, this is a description of the method or instrument used. For EVALUATIONs,
how the evaluation was arrived at. For INSTRUCTIONs, how to execute the Instruction.
This may take the form of references to guidelines, including manually followed and
executable; knowledge references such as a paper in Medline; clinical reasons within a largercare process. |
Parent Package: entry
Class ACTION
CARE_ENTRY
| +--ACTION
Used to record a clinical action that has been performed, which may have been ad hoc, or due to the execution of an Activity in an Instruction workflow. Every Action corresponds to a careflow step of some kind or another.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
description : ITEM_STRUCTURE | 1 | -- | | Description of the activity, in the form of an archetyped structure. |
time : DV_DATE_TIME | 1 | -- | | Point in time at which this action completed. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| ism_transition : ISM_TRANSITION | 1 | -- | Details of transition in the Instruction state machine caused by this Action. |
| instruction_details : INSTRUCTION_DETAILS | 0..1 | -- | Details to of the Instruction that caused this Action to be performed, if there was one. |
| Constraints |
| Name | Expression |
| Description_valid | inv: description <> Void |
| Ism_transition_valid | inv: ism_transition <> Void |
| Time_valid | inv: time <> Void |
Parent Package: entry
Class ACTIVITY
LOCATABLE
| +--ACTIVITY
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
action_archetype_id : String | 1 | -- | | Perl-compliant regular expression pattern, enclosed in ‘//’ delimiters, indicating the valid archetype identifiers of archetypes for Actions corresponding to this Activity specification. Defaults to “/.*/”, meaning any archetype. |
decription : ITEM_STRUCTURE | 1 | -- | | Description of the activity, in the form of an archetyped structure. |
timing : DV_PARSABLE | 1 | -- | | Timing of the activity, in the form of a parsable string, such as an HL7 GTS or ISO8601 string. |
| Constraints |
| Name | Expression |
| Timing_valid | inv: timing <> Void |
| Description_valid | inv: description <> Void
|
| Action_archteype_id_valid | inv: action_archetype_id <> Void and
action_archetype_ids.is_empty |
Parent Package: entry
Class ISM_TRANSITION
PATHABLE
| +--ISM_TRANSITION
Model of a transition in the Instruction State machine, caused by a careflow step.
The attributes document the careflow step as well as the ISM transition.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
careflow_step : DV_CODED_TEXT | 0..1 | -- | | The step in the careflow process which occurred as part of generating this action, e.g. “dispense”, “start_administration”.
This attribute represents the clinical label for the activity, as opposed to current_state which represents the state machine (ISM) computable form. Defined in archetype. |
current_state : DV_CODED_TEXT | 1 | -- | | The ISM current state. Coded by openEHR terminology group “Instruction states”. |
transition : DV_CODED_TEXT | 0..1 | -- | | The ISM transition which occurred to arrive in the current_state. Coded by openEHR terminology, group “ISM transitions”. |
| Constraints |
| Name | Expression |
| Current_state_valid | inv: current_state <> Void and
terminology(Terminology_id_openehr).
has_code_for_group_id(Group_id_ism_states, current_state.defining_code) |
| Transition_valid | inv: transition <> Void implies
terminology(Terminology_id_openehr).
has_code_for_group_id(Group_id_ism_transitions, transition.defining_code) |
Parent Package: entry
Class INSTRUCTION_DETAILS
PATHABLE
| +--INSTRUCTION_DETAILS
Used to record details of the Instruction causing an Action.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
activity_id : String | 1 | -- | | Identifier of Activity within Instruction, in the form of its archetype path. |
instruction_id : LOCATABLE_REF | 1 | -- | | Id of causing Instruction. |
wf_details : ITEM_STRUCTURE | 0..1 | -- | | Various workflow engine state details, potentially including such things as:
• condition that fired to cause this Action to be done (with actual variables substituted);
• list of notifications which actually occurred (with all variables substituted);
• other workflow engine state.
This specification does not currently define the actual structure or semantics of this field. |
| Constraints |
| Name | Expression |
| Activity_path_valid | inv: activity_id <> Void and not activity_id.is_empty |
| Instruction_id_valid | inv: instruction_id <> Void |
Parent Package: content
Package :: navigation
Parent Package: navigation
Class SECTION
CONTENT_ITEM
| +--SECTION
Represents a heading in a heading structure, or “section tree”.
| Constraints |
| Name | Expression |
| tems_valid | inv: items <> Void implies not items.is_empty |
Parent Package: rm
Package :: data_structures
Parent Package: data_structures
Class DATA_STRUCTURE{Abstract}
LOCATABLE
| +--DATA_STRUCTURE
Direct Subclassifiers:
HISTORY, ITEM_STRUCTURE
Parent Package: data_structures
Package :: history
The history package defines classes which formalise the concept of past, linear time, via which historical data of any structural complexity can be recorded. It supports both instantaneous and interval event samples within periodic and aperiodic series. Data recorded in interval events are tagged with a mathematical function, including ‘point-in-time’, ‘mean’, ‘delta’ and so on, as defined by the openEHR “event math function” vocabulary.
It also supports the inclusion of “summary” data, i.e. a textual or image item which summarises in some way the entire history.
Parent Package: history
Class HISTORY
DATA_STRUCTURE
| +--HISTORY
Root object of a linear history, i.e. time series structure..
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
duration : DV_DURATION | 0..1 | -- | | Duration of the entire History; either corresponds to the duration of all the events, and/or the duration represented by the summary, if it exists. |
origin : DV_DATE_TIME | 1 | -- | | Time origin of this event history. The first event is not necessarily at the origin point. |
period : DV_DURATION | 0..1 | -- | | Period between samples in this segment if periodic. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| summary : ITEM_STRUCTURE | 0..1 | -- | Optional summary data expressing e.g. text or image which summarises entire History. |
| events : List<EVENT> | 0..1 | 0..* ordered | The events in the series. |
| Operations |
| Signature | Constraints | Documentation |
as_hierarchy()
:
CLUSTER | | Generate a CEN EN13606-compatible hierarchy of the physical representation. |
is_periodic()
:
Boolean | | Indicates whether history is periodic. |
| Constraints |
| Name | Expression |
| events_exists | inv: (events <> Void and not events.is_empty) xor summary <> Void |
| periodic_validity | inv: is_periodic xor period = Void |
| origin_exists | inv: origin <> Void |
| period_consistency | inv: is_periodic implies events.for_all (e: EVENT | e.offset.to_seconds.mod(period.to_seconds) = 0) |
Parent Package: history
Class EVENT{Abstract}
LOCATABLE
| +--EVENT
Direct Subclassifiers:
INTERVAL_EVENT, POINT_EVENT
Defines the abstract notion of a single event in a series. This class is generic, allowing types to be generated which are locked to particular spatial types, such as EVENT. Subtypes express point or intveral data.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
state : ITEM_STRUCTURE | 0..1 | -- | | Optional state data for this event. |
time : DV_DATE_TIME | 1 | -- | | Time of this event. If the width is non-zero, it is the time point of the trailing edge of the event. |
| Operations |
| Signature | Constraints | Documentation |
offset()
:
DV_DURATION | | Offset of this event from origin. |
parent()
:
HISTORY | | Redefinition of LOCATABLE.parent to be of type HISTORY. |
| Constraints |
| Name | Expression |
| Offset_validity | inv: offset <> Void and offset = time - parent.origin |
| Time_exists | inv: time <> Void |
| Data_exists | inv: data <> Void |
Parent Package: history
Class POINT_EVENT
EVENT
| +--POINT_EVENT
Defines a single point event in a series.
Parent Package: history
Class INTERVAL_EVENT
EVENT
| +--INTERVAL_EVENT
Defines a single interval event in a series.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
math_function : DV_CODED_TEXT | 1 | -- | | Mathematical function of the data of this event, e.g. “maximum”, “mean” etc. Coded using openEHR Terminology group “event math function”. |
sample_count : Integer | 0..1 | -- | | Optional count of original samples to which this event corresponds. |
width : DV_DURATION | 1 | -- | | Length of the interval during which the state was true. Void if an instantaneous event. |
| Constraints |
| Name | Expression |
| Interval_start_time_valid | inv: interval_start_time <> Void |
| Math_function_validity | inv: terminology(Terminology_id_openehr).
has_code_for_group_id(Group_id_event_math_function,
math_function.defining_code) |
| Width_valid | inv: width <> Void |
Parent Package: data_structures
Package :: item_structure
Parent Package: item_structure
Class ITEM_TREE
ITEM_STRUCTURE
| +--ITEM_TREE
Logical tree data structure. The tree may be empty.
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| items : List<ITEM> | 0..1 | * ordered | Physical representation of the tree. |
| Operations |
| Signature | Constraints | Documentation |
as_hierarchy()
:
CLUSTER | | Generate a CEN EN13606-compatible hierarchy, which is the same as the tree’s physical representation. |
element_at_path(a_path : String)
:
ELEMENT |
pre: has_element_path(a_path) | Return the leaf element at the path ‘a_path’ |
has_element_path(a_path : String)
:
Boolean | | True if path ‘a_path’ is a valid leaf path |
Parent Package: item_structure
Class ITEM_LIST
ITEM_STRUCTURE
| +--ITEM_LIST
Logical list data structure, where each item has a value and can be referred to by a name and a positional index in the list. The list may be empty.
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| items : List<ELEMENT> | 0..1 | * ordered | Physical representation of the list. |
| Operations |
| Signature | Constraints | Documentation |
as_hierarchy()
:
CLUSTER | | Generate a CEN EN13606-compatible hierarchy consisting of a single CLUSTER containing the ELEMENTs of this list. |
item_count()
:
Integer | | Count of all items |
ith_item(i : Integer)
:
ELEMENT | | Retrieve the i-th item with name |
named_item(a_name : String)
:
ELEMENT | | Retrieve the item with name ‘a_name’ |
names()
:
List<DV_TEXT> | | Retrieve the names of all items |
| Constraints |
| Name | Expression |
| Names_valid | inv: names <> Void |
| Valid_structure | inv: items.forall(i:ITEM | i.type = 'ELEMENT')
|
Parent Package: item_structure
Class ITEM_SINGLE
ITEM_STRUCTURE
| +--ITEM_SINGLE
Logical single value data structure.
| Operations |
| Signature | Constraints | Documentation |
as_hierarchy()
:
ELEMENT | | Generate a CEN EN13606-compatible hierarchy consisting of a single ELEMENT. |
Parent Package: item_structure
Class ITEM_TABLE
ITEM_STRUCTURE
| +--ITEM_TABLE
Logical relational database style table data structure, in which columns are named and ordered with respect to each other.
Implemented using Cluster-per-row encoding. Each row Cluster must have an identical number of Elements, each of which in turn must have identical names and value types in the corresponding postions in each row.
Some columns may be designated ‘key’ columns, containing key data for each row, in the manner of relational tables. This allows row-naming, where each row represents a body site, a blood antigen etc. All values in a column have the same data type.
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| rows : List<CLUSTER> | 0..1 | * ordered | Physical representation of the table as a list of CLUSTERs, each containing the data of one row of the table. |
| Operations |
| Signature | Constraints | Documentation |
as_hierarchy()
:
CLUSTER | | Generate a CEN EN13606-compatible hierarchy consisting of a single CLUSTER containing the CLUSTERs representing the columns of this table. |
column_count()
:
Integer | | Return the number of columns |
column_names()
:
List<DV_TEXT> | | Return the column names |
element_at_cell_ij(i : Integer, j : Integer)
:
ELEMENT |
pre: i >= 1 and i <= column_count
pre: j >= 1 and j <= row_count | Return the element at the column i, row j. |
element_at_named_cell(row_key : String, col_key : Integer)
:
ELEMENT |
pre: has_row_with_name(row_key)
pre: has_column_with_name(column_key) | Return the element at the row whose first column has the name ‘row_key’ and column has the name ‘col_key’ |
has_column_with_name(a_key : String)
:
Boolean |
pre: a_key <> Void and not a_key.empty | True if there is a column with name ‘a_key’ |
has_row_with_key(keys : Set<String>)
:
Boolean | | True if there is a row whose first n columns have the names in ‘keys’ |
has_row_with_name(a_key : String)
:
Boolean |
pre: a_key <> Void and not a_key.empty | True if there is a row whose first column has the name ‘a_key’ |
ith_row(i : Integer)
:
CLUSTER |
pre: i >0 and i < row_count | Return the i-th row |
named_row(a_key : String)
:
CLUSTER |
pre: has_row_with_name(a_key) | Return the row whose first column has the name ‘a_key’ |
row_count()
:
Integer | | Return the number of rows |
row_names()
:
List<DV_TEXT> | | Return the row names |
row_with_key(key_vals : Set<String>)
:
CLUSTER |
pre: has_row_with_key(key_vals) | Return the row whose first n columns have names equal to the values in ‘keys’ |
| Constraints |
| Name | Expression |
| Column_names_valid | inv: column_names <> Void |
| Valid_structure | inv: rows.forall(items.forall(instance_of('ELEMENT')))
|
Parent Package: item_structure
Class ITEM_STRUCTURE{Abstract}
DATA_STRUCTURE
| +--ITEM_STRUCTURE
Direct Subclassifiers:
ITEM_TREE, ITEM_TABLE, ITEM_SINGLE, ITEM_LIST
Abstract parent class of all spatial data types.
Parent Package: data_structures
Package :: representation
Parent Package: representation
Class ITEM{Abstract}
Direct Subclassifiers:
ELEMENT, CLUSTER
The abstract parent of CLUSTER and ELEMENT representation classes.
Parent Package: representation
Class CLUSTER
ITEM
| +--CLUSTER
The grouping variant of ITEM, which may contain further instances of ITEM, in an ordered list.
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| items : List<ITEM> | 1 | 1..* ordered | Ordered list of items - CLUSTER or ELEMENT objects - under this CLUSTER. |
| Constraints |
| Name | Expression |
| Items_non_empty | inv: items <> Void and not items.empty |
Parent Package: representation
Class ELEMENT
ITEM
| +--ELEMENT
The leaf variant of ITEM, to which a DATA_VALUE instance is attached.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
null_flavor : DV_CODED_TEXT | 0..1 | -- | | flavour of null value, e.g. indeterminate, not asked etc |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| value : DATA_VALUE | 0..1 | -- | data value of this leaf |
| value : DATA_VALUE | 0..1 | -- |
|
| Operations |
| Signature | Constraints | Documentation |
is_null()
:
Boolean | | True if value logically not known, e.g. if indeterminate, not asked etc. |
| Constraints |
| Name | Expression |
| Null_flavour_valid | inv: is_null implies
terminology(Terminology_id_openehr).has_code_for_group_id
(Group_id_null_flavour, null_flavor.defining_code) |
| Null_flavor_indicated | inv: is_null xor null_flavour <> Void |
| Is_null_valid | inv: is_null = (value = Void) |
Parent Package: rm
Package :: data_types
Parent Package: data_types
Package :: basic
Parent Package: basic
Class DV_BOOLEAN
DATA_VALUE
| +--DV_BOOLEAN
Items which are truly boolean data, such as true/false or yes/no answers.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
value : Boolean | 1 | -- | | Boolean value of this item. |
| Constraints |
| Name | Expression |
| Value_exists | inv: value <> Void |
Parent Package: basic
Class DV_STATE
DATA_VALUE
| +--DV_STATE
For representing state values which obey a defined state machine, such as a variable representing the states of an instruction or care process.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
is_terminal : Boolean | 1 | -- | | Indicates whether this state is a terminal state, such as “aborted”, “completed” etc from which no further transitions are possible. |
value : DV_CODED_TEXT | 1 | -- | | The state name. State names are determined by a state/event table defined in archetypes, and coded using openEHR Terminology or local archetype terms, as specified by the archetype. |
| Constraints |
| Name | Expression |
| value_exists | inv: value <> Void |
| Is_terminal_exists | inv: is_terminal <> Void |
| Value_validity | inv: value <> void |
Parent Package: basic
Class DV_IDENTIFIER
DATA_VALUE
| +--DV_IDENTIFIER
Type for representing identifiers of real-world entities. Typical identifiers include drivers licence number, social security number, vertans affairs number, prescription id, order id, and so on.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
assigner : String | 1 | -- | | Organisation that assigned the id to the item being identified. |
id : String | 1 | -- | | The identifier value. Often structured, according to the definition of the issuing authority’s rules. |
issuer : String | 1 | -- | | Authority which issues the kind of id used in the id field of this object. |
type : String | 1 | -- | | The identifier type, such as “prescription”, or “SSN”. One day a controlled vocabulary might be possible for this. |
| Constraints |
| Name | Expression |
| issuer_valid | inv: issuer <> Void and not issuer.is_empty |
| id_valid | inv: id <> Void and not id.is_empty |
| type_valid | inv: type <> Void and not type.is_empty |
| assigner_valid | inv: issuer <> Void and not assigner.is_e |
Parent Package: basic
Class DATA_VALUE{Abstract}
BASIC_DEFINITIONS
| +--DATA_VALUE
Direct Subclassifiers:
DV_PARAGRAPH, DV_URI, DV_IDENTIFIER, DV_INTERVAL, DV_STATE, DV_BOOLEAN, DV_ENCAPSULATED, DV_TEXT, DV_TIME_SPECIFICATION, DV_ORDERED
Serves as a common ancestor of all data value types in openEHR models.
Parent Package: data_types
Package :: encapsulated
The data_types.encapsulated package contains classes representing data values whose internal structure is defined outside the EHR model, such as multimedia and parsable data.
Parent Package: encapsulated
Class DV_ENCAPSULATED{Abstract}
DATA_VALUE
| +--DV_ENCAPSULATED
Direct Subclassifiers:
DV_PARSABLE, DV_MULTIMEDIA
Abstract class defining the common meta-data of all types of encapsulated data.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
charset : CODE_PHRASE | 0..1 | -- | | Name of character encoding scheme in which this value is encoded. Coded from openEHR Code Set “character sets”. Unicode is the default assumption in openEHR, with UTF-8 being the assumed encoding. This attribute allows for variations from these assumptions. |
language : CODE_PHRASE | 0..1 | -- | | Optional indicator of the localised language in which the data is written, if relevant.
Coded from openEHR Code Set “languages”. |
| Operations |
| Signature | Constraints | Documentation |
size()
:
Integer | | Original size in bytes of unencoded encapsulated data. I.e. encodings such as base64, hexadecimal etc do not change the value of this attribute. |
| Constraints |
| Name | Expression |
| Size_positive | inv: size >= 0 |
| Charset_valid | inv: charset <> Void and
code_set(Code_set_id_character_sets).has_code(charset) |
| Language_valid | inv: language <> Void and
code_set(Code_set_id_languages).has_code(language) |
| Size_positive | inv: size >=0 |
Parent Package: encapsulated
Class DV_MULTIMEDIA
DV_ENCAPSULATED
| +--DV_MULTIMEDIA
A specialisation of DV_ENCAPSULATED for audiovisual and biosignal types.
Includes further metadata relating to multimedia types which are not applicable t other subtypes of DV_ENCAPSULATED.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
alternate_text : String | 0..1 | -- | | Text to display in lieu of multimedia display/replay |
compression_algorithm : CODE_PHRASE | 0..1 | -- | | compression type, a coded value from the openEHR “Integrity check” code set. Void means no compression. |
data : Array<Octet> | 0..1 | -- | | the actual data found at 'uri', if supplied inline |
integrity_check : Array<Octet> | 0..1 | -- | | binary cryptographic integrity checksum |
integrity_check_algorithm : CODE_PHRASE | 0..1 | -- | | type of integrity check, a coded value from the openEHR “Integrity check” code set. |
media_type : CODE_PHRASE | 1 | -- | | Data media type coded from the IANA MIME types code set. See:
http://www.iana.org/assignments/mediatypes/ |
size : Integer | 1 | -- | | |
uri : DV_URI | 0..1 | -- | | URI reference to electronic information stored outside the record as a file, database entry etc, if supplied as a reference. |
| Operations |
| Signature | Constraints | Documentation |
has_integrity_check()
:
Boolean |
post: integrity_check_algorithm <> Void implies Result | Computed from the value of the integrity_check_algorithm attribute: True if an integrity check has been computed. |
is_compressed()
:
Boolean |
post: compression_algorithm <> Void implies Result | Computed from the value of the compression_algorithm attribute: True if the data is stored in compressed form. |
is_external()
:
Boolean |
post: uri <> Void implies Result | Computed from the value of the uri attribute: True if the data is stored externally to the record, as indicated by `uri'. A copy may also be stored internally, in which case `is_expanded' is also true. |
is_inline()
:
Boolean |
post: data <> Void implies Result | Computed from the value of the data attribute: True if the data is stored in expanded form, ie within the EHR itself. |
| Constraints |
| Name | Expression |
| Integrity_check_algorithm_validity | inv: integrity_check_algorithm <> Void implies
code_set('integrity_check algorithm').has(integrity_check_algorithm) |
| Integrity_check_validity | inv: integrity_check_algorithm <> Void implies
code_set(Code_set_id_integrity_check_algorithms).
has_code(integrity_check_algorithm) |
| Media_type_validity | inv: media_type <> Void and
code_set(Code_set_id_media_types).has_code(media_type) |
| Compression_algorithm_validity | inv: compression_algorithm <> Void implies
code_set(Code_set_id_compression_algorithms).
has_code(compression_algorithm) |
| Not_empty | inv: is_inline or is_external |
Parent Package: encapsulated
Class DV_PARSABLE
DV_ENCAPSULATED
| +--DV_PARSABLE
Encapsulated data expressed as a parsable String. The internal model of the data item is not described in the openEHR model in common with other encapsulated types, but in this case, the form of the data is assumed to be plaintext, rather than compressed or other types of large binary data.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
formalism : String | 1 | -- | | name of the formalism, e.g. “GLIF 1.0”, “proforma” etc. |
value : String | 1 | -- | | the string, which may validly be empty in some syntaxes |
| Constraints |
| Name | Expression |
| formalism_validity | inv: formalism <> Void and not formalism.is_empty |
| value_valid | inv: value <> Void |
Parent Package: data_types
Package :: quantity
Parent Package: quantity
Class DV_ORDERED
DATA_VALUE
| +--DV_ORDERED
Direct Subclassifiers:
DV_QUANTIFIED, DV_ORDINAL
Abstract class defining the concept of ordered values, which includes ordinals as well as true quantities. It defines the functions ‘<’ and is_strictly_comparable_to, the latter of which must evaluate to True for instances being compared with the ‘<’ function, or used as limits in the DV_INTERVAL class.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
normal_status : CODE_PHRASE | 0..1 | -- | | Optional normal status indicator of value with respect to normal range for this value. Often included by lab, even if the normal range itself is not included. Coded by ordinals in series HHH, HH, H, (nothing), L, LL, LLL; see openEHR terminology group “normal status”. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| other_reference_ranges : Set<REFERENCE_RANGE> | 0..1 | 0..* | optional tagged ranges for this value in its particular measurement context |
| normal_range : DV_INTERVAL | 0..1 | -- | Optional normal range. |
| Operations |
| Signature | Constraints | Documentation |
infix('<' : Character, other : DV_ORDERED)
:
DV_ORDERED |
pre:is_strictly_comparable_to(other) | Tests if this item is less than other, which must be of the same concrete type. |
is_normal()
:
Boolean |
pre: normal_range <> Void or normal_status <> Void
post:normal_range <> Void implies Result
= normal_range.has(Current)
post: normal_status <> Void implies
normal_status.code_string.is_equal('N') | Value is in the normal range, determined by comparison of the value to the normal_range if present, or by the normal_status marker if present. |
is_simple()
:
Boolean | | True if this quantity has no reference ranges or accuracy. |
is_strictly_comparable_to(t : DV_ORDERED)
:
Boolean | | Test if two instances are strictly comparable. |
| Constraints |
| Name | Expression |
| Is_simple_validity | inv: (normal_range = Void and other_reference_ranges = Void)
implies is_simple |
| Other_reference_ranges_validity | inv: other_reference_ranges <> Void implies not
other_reference_ranges.is_empty |
| normal_status_validity | inv: normal_status <> Void implies
code_set(Code_set_id_normal_statuses).has_code(normal_status) |
| Normal_range_and_status_consistency | inv: (normal_range <> Void and
normal_status <> Void) implies (normal_status.code_string.is_equal('N') xor
not normal_range.has(Current)) |
Parent Package: quantity
Class DV_QUANTIFIED
DV_ORDERED
| +--DV_QUANTIFIED
Direct Subclassifiers:
DV_ABSOLUTE_QUANTITY, DV_AMOUNT
Abstract class defining the concept of true quantified values, i.e. values which are
not only ordered, but which have a precise magnitude.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
magnitude_status : String | 0..1 | -- | | Optional status of magnitude with values:
• “=” : magnitude is a point value
• “<“ : value is < magnitude
• “>” : value is > magnitude
• “<=” : value is <= magnitude
• “>=” : value is >= magnitude
• “~” : value is approximately magnitude
If not present, meaning is “=”. |
| Operations |
| Signature | Constraints | Documentation |
magnitude()
:
Ordered_Numeric | | Numeric value of the quantity in canonical (i.e. single value) form. Implemented as constant, function or attribute in subtypes as appropriate. The type Ordered_numeric is mapped to the available appropriate type in each implementation technology. |
valiid_magnitude_status(s : String)
:
Boolean |
post: Result = s.is_equal('=') or
s.is_equal('<') or
s.is_equal('>') or
s.is_equal('<=') or
s.is_equal('>=') or
s.is_equal('~') | Test whether a string value is one of the valid values for the magnitude_status attribute. |
| Constraints |
| Name | Expression |
| Magnitude_exists | inv: magnitude <> Void |
| Magnitude_status_valid | inv: magnitude_status <> Void implies
valid_magnitude_status(magnitude_status) |
Parent Package: quantity
Class REFERENCE_RANGE
Defines a named range to be associated with any ORDERED datum. Each such range is particular to the patient and context, e.g. sex, age, and any other factor which affects ranges.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
meaning : DV_TEXT | 0..1 | -- | | Term whose value indicates the meaning of this range, e.g. “normal”, “critical”, “therapeutic” etc. |
| Operations |
| Signature | Constraints | Documentation |
is_in_range(v : T)
:
Boolean | | Indicates if the value ‘val’ is inside the range |
| Constraints |
| Name | Expression |
| Meaning_exists | inv: meaning <> Void |
| Range_exists | inv: range <> Void |
| Range_is_simple | inv: (range.lower_unbounded or range.lower.is_simple) and
(range.upper_unbounded or range.upper.is_simple) |
Parent Package: quantity
Class DV_ORDINAL
DV_ORDERED
| +--DV_ORDINAL
Models rankings and scores, e.g. pain, Apgar values, etc, where there is a)
implied ordering, b) no implication that the distance between each value is constant,
and c) the total number of values is finite.
Note that although the term ‘ordinal’ in mathematics means natural numbers only, here any integer is allowed, since negative and zero values are often used by medical professionals
for values around a neutral point. Examples of sets of ordinal values:
-3, -2, -1, 0, 1, 2, 3 -- reflex response values
0, 1, 2 -- Apgar values
Used for recording any clinical datum which is customarily recorded using symbolic
values. Example: the results on a urinalysis strip, e.g. {neg, trace, +,
++, +++} are used for leucocytes, protein, nitrites etc; for non-haemolysed
blood {neg, trace, moderate}; for haemolysed blood {neg, trace,
small, moderate, large}.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
symbol : DV_CODED_TEXT | 1 | -- | | Coded textual representation of this value in the enumeration, which may be strings made from “+” symbols, or other enumerations of terms such as “mild”, “moderate”, “severe”, or even the same number series as the values, e.g. “1”, “2”, “3”.
Codes come from archetype. |
value : Integer | 1 | -- | | ordinal position in enumeration of values. |
| Operations |
| Signature | Constraints | Documentation |
infix('<' : Character, other : DV_ORDINAL)
:
DV_ORDINAL |
post: value < other.value implies Result | True if types are the same and values compare |
is_strictly_comparable_to()
:
Boolean |
post: symbol.is_comparable (other.symbol) implies Result | True if symbols come from same vocabulary, assuming the vocabulary is a subset or value range, e.g. “urine:protein”. |
limits()
:
REFERENCE_RANGE | | limits of the ordinal enumeration, to allow comparison of an ordinal value to its limits. |
| Constraints |
| Name | Expression |
| Symbol_exists | inv: symbol <> Void |
| Reference_range_valid | inv: other_reference_ranges <> Void and
other_reference_ranges.has(limits) |
| Limits_valid | inv: limits <> Void and limits.meaning.is_equal('limits') |
| Value_valid | inv: value > 0 |
Parent Package: quantity
Class DV_COUNT
DV_AMOUNT
| +--DV_COUNT
Countable quantities.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
magnitude : Integer | 1 | -- | | numeric magnitude of the quantity |
Parent Package: quantity
Class DV_QUANTITY
DV_AMOUNT
| +--DV_QUANTITY
Quantitified type representing “scientific” quantities, i.e. quantities expressed as a
magnitude and units.
Units were inspired by the Unified Code for Units of Measure (UCUM), developed
by Gunther Schadow and Clement J. McDonald of The Regenstrief Institute
Can also be used for time durations, where it is more convenient to treat these as
simply a number of seconds rather than days, months, years.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
magnitude : Double | 1 | -- | | numeric magnitude of the quantity. |
precision : Integer | 0..1 | -- | | Precision to which the value of the quantity is expressed, in terms of number of decimal places. The value 0 implies an integral quantity.
The value -1 implies no limit, i.e. any number of decimal places. |
units : String | 1 | -- | | Stringified units, expressed in UCUM unit syntax,
e.g. "kg/m2", “mm[Hg]", "ms-1", "km |
| Operations |
| Signature | Constraints | Documentation |
is_integral()
:
Boolean | | True if precision = 0; quantity represents an integral number. |
is_strictly_comparable_to(other : DV_QUANTITY)
:
Boolean |
pre: units_equivalent(units,other.units) | Test if two instances are strictly comparable by ensuring that the measured property is the same, achieved using the Measurement service function units_equivalent. |
| Constraints |
| Name | Expression |
| Precision_valid | inv: precision >= 0 |
Parent Package: quantity
Class DV_INTERVAL<DV_DATE_TIME>
Parent Package: quantity
Class DV_PROPORTION
DV_AMOUNT, PROPORTION_KIND
| +--DV_PROPORTION
Models a ratio of values, i.e. where the numerator and denominator are both pure numbers.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
denominator : Real | 1 | -- | | denominator of ratio |
numerator : Real | 1 | -- | | numerator of ratio |
precision : Integer | 0..1 | -- | | Precision to which the numerator and denominator values of the proportion are expressed, in terms of number of decimal places. The value 0 implies an integral quantity.
The value -1 implies no limit, i.e. any number of decimal places. |
type : Integer | 1 | -- | | Indicates semantic type of proportion, including percent, unitary.
Codes are given in PROPORTION_KIND class. |
| Operations |
| Signature | Constraints | Documentation |
is_strictly_comparable_to(other : DV_PROPORTION)
:
Boolean |
post: other.type implies result | True if type is the same. |
magnitude()
:
Real |
post: Result = numerator/denominator | Effective magnitude represented by ratio. |
| Constraints |
| Name | Expression |
| Is_integral_validity | inv: is_integral implies (numerator.floor = numerator and
denominator.floor = denominator) |
| Type_validity | inv: valid_proportion_kind(type) |
| Fraction_validity | inv: (type = pk_fraction or type = pk_integer_fraction) implies
is_integral |
| Unitary_validity | inv: type = pk_unitary implies denominator = 1 |
| Percent_validity | inv: type = pk_percent implies denominator = 100 |
| Precision_validity | inv: precision = 0 implies is_integral |
Parent Package: quantity
Class PROPORTION_KIND
Direct Subclassifiers:
DV_PROPORTION
Class of enumeration constants defining types of proportion for the DV_PROPORTION class.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
pk_fraction : Integer | 1 | -- | 3 | Treat as a Constant.
Numerator and denominator are integral, and the presentation method uses a slash, e.g. “1/2”. |
pk_integer_fraction : Integer | 1 | -- | 4 | Treat as a Constant.
Numerator and denominator are integral, and the presentation method uses a slash, e.g. “1/2”; if
the numerator is greated than the denominator, e.g. n=3, d=2, the presentation is “1 1/2”. |
pk_percent : Integer | 1 | -- | 2 | Treat as Constant.
Denominator is 100, numerator is understood as a percentage value. |
pk_ratio : Integer | 1 | -- | 0 | Treat as a Constant.
Ratio type. Numerator and denominator may be any value |
pk_unitary : Integer | 1 | -- | 1 | Treat as a Constant.
Denominator must be 1 |
| Operations |
| Signature | Constraints | Documentation |
valid_proportion_kind(n : Integer)
:
Boolean | | True if n is one of the defined types in PROPORTION_KIND. |
Parent Package: quantity
Class DV_AMOUNT
DV_QUANTIFIED
| +--DV_AMOUNT
Direct Subclassifiers:
DV_PROPORTION, DV_DURATION, DV_QUANTITY, DV_COUNT
Abstract class defining the concept of relative quantified ‘amounts’. For relative quantities, the ‘+’ and ‘-’ operators are defined (unlike descendants of DV_ABSOLUTE_QUANTITY, such as the date/time types).
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
accuracy : Real | 0..1 | -- | | Accuracy of measurement, expressed either as a half-range percent value (Accuracy_is_percent = True) or a half-range quantity.
A value of 0 means that accuracy
was not recorded. |
accuracy_is_percent : Boolean | 0..1 | -- | | If True, indicates that when this object was created, accuracy was recorded as a percent value; if False, as an absolute quantity value. |
| Operations |
| Signature | Constraints | Documentation |
infix(other : DV_AMOUNT, '+' : Character)
:
DV_AMOUNT | | Sum of this quantity and another whose formal type must be the difference type of this quantity. |
infix(other : DV_AMOUNT, '-' : Character)
:
DV_AMOUNT | | Difference of this quantity and another whose formal type must be the difference type of this quantity type. |
prefix('-' : Character)
:
DV_AMOUNT | | Negated version of current object, such as used for representing a difference, e.g. a weight loss. |
valid_percentage(val : Numeric)
:
|
post: Result implies val >= 0.0 and
val <= 100.0 | Test whether a number is a valid percentage, i.e. between 0 and 100. |
| Constraints |
| Name | Expression |
| Accuracy_validity | inv: accuracy_is_percent implies valid_percentage(accuracy) |
| Accuracy_is_percent_validity | inv: accuracy = 0 implies not accuracy_is_percent |
Parent Package: quantity
Class DV_ABSOLUTE_QUANTITY{Abstract}
DV_QUANTIFIED
| +--DV_ABSOLUTE_QUANTITY
Direct Subclassifiers:
DV_TEMPORAL
Abstract class defining the concept of quantified entities whose values are absolute with respect to an origin. Dates and Times are the main example.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
accuracy : DV_AMOUNT | 0..1 | -- | | Accuracy of measurement, expressed as a half-range value of the diff type for this absolute quantity (i.e. an accuracy of x means +/−x). |
| Operations |
| Signature | Constraints | Documentation |
add(a_diff : Any)
:
DV_ABSOLUTE_QUANTITY | | Addition of a differential amount to this quantity.
The return type is a DV_ABSOLUTE_QUANTITY of the same type that was added to. |
diff(other : DV_ABSOLUTE_QUANTITY)
:
DV_AMOUNT | | Difference of two absolute quantities. |
subtract(a_diff : Any)
:
DV_ABSOLUTE_QUANTITY | | Subtraction of a differential amount to this quantity.
The return type is a DV_ABSOLUTE_QUANTITY of the same type that was subtracted from. |
Parent Package: quantity
Package :: date_time
The data_types.quantity.date_time package includes three absolute date/time concepts:
DV_DATE, DV_TIME, DV_DATE_TIME, a relative concept: DV_DURATION, and the concept of partial dates and times, via DV_PARTIAL_DATE, DV_PARTIAL_TIME.
Parent Package: date_time
Class DV_DURATION
DV_AMOUNT
| +--DV_DURATION
Implemented Classifiers:
TIME_DEFINITIONS, ISO8601_DURATION
Represents a period of time with respect to a notional point in
time, which is not
specified. A sign may be used to indicate the duration is
“backwards” in time
rather than forwards.
Note that a deviation from ISO8601 is
supported, allowing the ‘W’ designator to
be mixed with other designators. See
assumed types section in the Support IM.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
value : String | 1 | -- | | ISO8601 duration |
| Operations |
| Signature | Constraints | Documentation |
magnitude()
:
double |
post: Result >= 0.0 | numeric value of the duration as seconds |
prefix('-' : Character)
:
DV_DURATION | | Negated copy of current object
Return type is like Current
|
| Constraints |
| Name | Expression |
| Value_validity | inv: is_valid_iso8601_duration(value) |
Parent Package: date_time
Class DV_DATE
DV_TEMPORAL
| +--DV_DATE
Implemented Classifiers:
ISO8601_DATE
Represents an absolute point in time, as measured on the Gregorian calendar, and
specified only to the day. Semantics defined by ISO 8601.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
value : String | 1 | -- | | ISO8601 date string |
| Operations |
| Signature | Constraints | Documentation |
magnitude()
:
Integer |
post: Result >= 0 | numeric value of the date as seconds since the calendar origin point 1/1/0000 |
| Constraints |
| Name | Expression |
| Value_valid | inv: valid_iso8601_date(value) |
Parent Package: date_time
Class DV_TIME
DV_TEMPORAL
| +--DV_TIME
Implemented Classifiers:
ISO8601_TIME
Represents an absolute point in time from an origin usually interpreted as meaning
the start of the current day, specified to the second. Semantics defined by ISO 8601.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
value : String | 1 | -- | | ISO8601 time string |
| Operations |
| Signature | Constraints | Documentation |
magnitude()
:
double |
post: Result >= 0.0 | Numeric value of the time as seconds since the start of day |
| Constraints |
| Name | Expression |
| Value_valid | inv: valid_iso8601_time(value) |
Parent Package: date_time
Class DV_DATE_TIME
DV_TEMPORAL
| +--DV_DATE_TIME
Implemented Classifiers:
ISO8601_DATE_TIME
Represents an absolute point in time, specified to the second. Semantics defined
by ISO 8601.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
value : String | 1 | -- | | ISO8601 date/time string |
| Operations |
| Signature | Constraints | Documentation |
magnitude()
:
double |
post: Result >= 0.0 | numeric value of the date/time as days since the calendar origin point |
| Constraints |
| Name | Expression |
| Value_valid | inv: valid_iso8601_date_time(value) |
Parent Package: date_time
Class DV_INTERVAL
DATA_VALUE, Interval
| +--DV_INTERVAL
Generic class defining an interval (i.e. range) of a comparable type. An interval is a contiguous subrange of a comparable base type.
| Constraints |
| Name | Expression |
| Limits_consistent | inv: (not upper_unbounded and not lower_unbounded) implies
(lower.is_strictly_comparable_to(upper) and lower <= upper) |
Parent Package: date_time
Class DV_TEMPORAL{Abstract}
DV_ABSOLUTE_QUANTITY
| +--DV_TEMPORAL
Direct Subclassifiers:
DV_DATE_TIME, DV_TIME, DV_DATE
Specialised temporal variant of DV_ABSOLUTE_QUANTITY whose diff type is
DV_DURATION.
| Operations |
| Signature | Constraints | Documentation |
diff(other : DV_TEMPORAL)
:
DV_DURATION | | Difference of two temporal quantities |
Parent Package: data_types
Package :: text
Represents a coded term mapped to a DV_TEXT, and the relative match of the target term with respect to the mapped item. Plain or coded text items may appear in the EHR for which one or mappings in alternative terminologies are required.
Mappings are only used to enable computer processing, so they can only be instances of DV_CODED_TEXT.
Parent Package: text
Class DV_PARAGRAPH
DATA_VALUE
| +--DV_PARAGRAPH
A logical composite text value consisting of a series of DV_TEXTs, i.e. plain text (optionally coded) potentially with simple formatting, to form a larger tract of prose, which may be interpreted for display purposes as a paragraph.
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| items : Set<DV_TEXT> | 1 | 1..* | Items making up the paragraph, each of hich is a text item (which may have its own formatting, and/or have hyperlinks). |
| Constraints |
| Name | Expression |
| items_exists | inv: items <> void and not items.is_empty |
Parent Package: text
Class DV_TEXT
DATA_VALUE
| +--DV_TEXT
Direct Subclassifiers:
DV_CODED_TEXT
A plain text item, which may contain any amount of legal characters arranged as e.g. words, sentences etc (i.e. one DV_TEXT may be more than one word). Any DV_TEXT may be “coded” by adding mappings to it.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
formatting : String | 0..1 | -- | | A format string of the form “name:value; name:value...”, e.g. "font-weight : bold; font-family : Arial; font-size : 12pt;". Values taken from W3C CSS2 properties lists “background” and “font”. |
hyperlink : DV_URI | 0..1 | -- | | Optional link sitting behind a section of plain text or coded term item. |
value : String | 1 | -- | | Displayable rendition of the item, regardless of its underlying structure. For DV_CODED_TEXT, this is the rubric of the complete term as provided by the terminology service. No carriage returns, line feeds, or other non-printing characters permitted. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| mappings : Set<TERM_MAPPING> | 0..1 | 0..* | terms from other terminologies most closely matching this term, typically used where the originator (e.g. pathology lab) of information uses a local terminology but also supplies one or more equivalents from wellknown terminologies (e.g. LOINC). |
| language : CODE_PHRASE | 0..1 | -- | |
| encoding : CODE_PHRASE | 0..1 | -- | |
| Constraints |
| Name | Expression |
| Language_valid | inv: language <> Void implies
code_set(Code_set_id_languages).has_code(language)) |
| Value_valid | inv: value <> void and not value.is_empty and not
(value.has(CR) or value.has(LF)) |
| Mappings_valid | inv: mappings <> void implies not mappings.is_empty |
| Encoding_valid | inv: encoding <> Void implies
code_set(Code_set_id_character_sets).has_code(encoding) |
| Formatting_valid | inv: formatting <> void implies not formatting.is_empty |
Parent Package: text
Class TERM_MAPPING
Represents a coded term mapped to a DV_TEXT, and the relative match of the target term with respect to the mapped item. Plain or coded text items may appear in the EHR for which one or mappings in alternative terminologies are required. Mappings are only used to enable computer processing, so they can only be instances of DV_CODED_TEXT.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
match : Character | 1 | -- | | The relative match of the target term with respect to the mapped text item. Result meanings:
• ‘>’: the mapping is to a broader term e.g. orginal text = “arbovirus infection”, target = “viral infection”
• ‘=’: the mapping is to a (supposedly) equivalent to the original item
• ‘<’: the mapping is to a narrower term. e.g. original text = “diabetes”, mapping = “diabetes mellitus”.
• ‘?’: the kind of mapping is unknown.
The first three values are taken from the ISO standards 2788 (“Guide to Establishment and development of monolingual thesauri”) and 5964 (“Guide to Establishment and development of multilingual thesauri”). |
purpose : DV_CODED_TEXT | 0..1 | -- | | Purpose of the mapping e.g. “automated data mining”, “billing”, “interoperability” |
| Operations |
| Signature | Constraints | Documentation |
broader()
:
Boolean |
post:match = ‘>’ implies Result | The mapping is to a broader term. |
equivalent()
:
Boolean |
post:match = ‘=’ implies Result | The mapping is to an equivalent term. |
is_valid_match_code(c : Character)
:
Boolean |
post: Result := c = ‘>’ or c = ‘=’ or c =
‘<’ or c = ‘?’ | True if match valid. |
narrower()
:
Boolean |
post: match = ‘<’ implies Result | The mapping is to a narrower term. |
unknown()
:
Boolean |
post: match = ‘?’ implies Result | The kind of mapping is unknown. |
| Constraints |
| Name | Expression |
| Match_valid | inv: is_valid_match_code(match) |
| Purpose_valid | inv: purpose <> Void implies
terminology(Terminology_id_openehr).
has_code_for_group_id(Group_id_term_mapping_purpose, purpose.
defining_code) |
| Target_exists | inv: target <> Void |
Parent Package: text
Class DV_CODED_TEXT
DV_TEXT
| +--DV_CODED_TEXT
A text item whose value must be the rubric from a controlled terminology, the key (i.e. the ‘code’) of which is the defining_code attribute. In other words: a DV_CODED_TEXT is a combination of a CODE_PHRASE (effectively a code) and the rubric of that term, from a terminology service, in the language in which the data was authored.
| Constraints |
| Name | Expression |
| Definition_exists | inv: defining_code <> Void |
Parent Package: text
Class CODE_PHRASE
A fully coordinated (i.e. all “coordination” has been performed) term from a terminology service (as distinct from a particular terminology).
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
code_string : String | 1 | -- | | The key used by the terminology service to identify a concept or coordination of concepts. This string is most likely parsable inside the terminology service, but nothing can be assumed
about its syntax outside that context. |
terminology_id : TERMINOLOGY_ID | 1 | -- | | Identifier of the distinct terminology from which the code_string (or its elements) was extracted. |
| Constraints |
| Name | Expression |
| Terminology_id_exists | inv: terminology_id <> Void |
| Code_string_exists | inv: code_string <> Void and not code_string.is_empty |
Parent Package: data_types
Package :: time_specification
Parent Package: time_specification
Class DV_TIME_SPECIFICATION
DATA_VALUE
| +--DV_TIME_SPECIFICATION
Direct Subclassifiers:
DV_PERIODIC_TIME_SPECIFICATION, DV_GENERAL_TIME_SPECIFICATION
Parent Package: time_specification
Class DV_PERIODIC_TIME_SPECIFICATION
DV_TIME_SPECIFICATION
| +--DV_PERIODIC_TIME_SPECIFICATION
| Constraints |
| Name | Expression |
| Value_valid | inv: value.formalism.is_equal('HL7:PIVL') or value.formalism. is_equal('HL7:EIVL') |
Parent Package: time_specification
Class DV_GENERAL_TIME_SPECIFICATION
DV_TIME_SPECIFICATION
| +--DV_GENERAL_TIME_SPECIFICATION
| Constraints |
| Name | Expression |
| Value_valid | inv: value.formalism.is_equal('HL7:GTS') |
Parent Package: data_types
Package :: uri
Parent Package: uri
Class DV_URI
DATA_VALUE
| +--DV_URI
Direct Subclassifiers:
DV_EHR_URI
A reference to an object which conforms to the Universal Resource Identifier (URI) standard, as defined by W3C RFC 2936. See "Universal Resource Identifiers in WWW" by Tim Berners-Lee at http://www.ietf.org/rfc/rfc2396.txt.
This is a World-Wide Web RFC for global identification of resources.
See http://www.w3.org/Addressing for a starting point on URIs.
See http://www.ietf.org/rfc/rfc2806.txt for new URI types like telephone, fax and modem numbers.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
value : String | 1 | -- | | Value of URI as a String. |
| Operations |
| Signature | Constraints | Documentation |
fragment_id()
:
String | | A part of, a fragment or a sub-function within an object. Allows references to sub-parts of objects, such as a certain line and character position in a text object. The syntax and semantics are defined by the application responsible for the object. |
path()
:
String | | A string whose format is a function of the scheme. Identifies the location in - space of an information entity. Typical values include hierarchical directory paths for any machine. For example, with scheme = "ftp", path might be /pub/images/image_01. The strings "." and ".." are reserved for use in the path.
Paths may include internet/intranet location identifiers of the form: sub_domain...domain, e.g. "info.cern.ch" |
query()
:
String | | Query string to send to application implied by scheme and path Enables queries to applications, including databases to be included in the URI Any query meaningful to the server, including SQL. |
scheme()
:
String | | A distributed information "space" in which information objects exist. The scheme simultaneously specifies an information space and a mechanism for accessing objects in that space.
For example if scheme = "ftp", it identifies the information space in which all ftpable objects exist, and also the application - ftp - which can be used to access them.
Values may include: "ftp", "telnet", "mailto", "gopher" and many others. Refer to WWW URI RFC for a full list.
New information spaces can be accommodated within the URI specification. |
| Constraints |
| Name | Expression |
| value_exists | inv: value <> Void and not value.is_empty |
Parent Package: uri
Class DV_EHR_URI
DV_URI
| +--DV_EHR_URI
A DV_EHR_URI is a DV_URI which has the scheme name “ehr”, and which can
only reference elements in EHRs
| Constraints |
| Name | Expression |
| Scheme_is_ehr | inv: scheme.is_equal(Ehr_scheme) |
Parent Package: rm
Package :: demographic
This document describes the architecture of the openEHR Demographic Information Model. The
semantics are drawn from previous work in GEHR, existing models in CEN 13606 and the HL7v3
RIM, and other work done in Australia.
The intended audience includes:
• Standards bodies producing health informatics standards;
• Software development groups using openEHR;
• Academic groups using openEHR;
• The open source healthcare community;
• Medical informaticians and clinicians intersted in health information;
• Health data managers.
Parent Package: demographic
Class PARTY_RELATIONSHIP
LOCATABLE
| +--PARTY_RELATIONSHIP
Generic description of a relationship between parties.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
details : DATA_STRUCTURE | 0..1 | -- | | The detailed description of the relationship |
source : PARTY_REF | 1 | -- | | Source of relationship. |
target : PARTY_REF | 1 | -- | | Target of relationship. |
time_validity : DV_INTERVAL<DV_DATE> | 0..1 | -- | | Valid time interval for this relationship. |
uid : HIER_OBJECT_ID | 1 | -- | | (Redefined) Identifier of this Party. |
| Operations |
| Signature | Constraints | Documentation |
type()
:
DV_TEXT | | Type of relationship, such as “employment”, “authority”, “health provision” |
| Constraints |
| Name | Expression |
| Target_valid | inv: target <> Void and not target.reverse_relationships.has(Current) |
| Source_valid | inv: source <> Void and source.relationships.has(Current) |
| Type_validity | inv: type = name |
| Uid_valid | inv: uid <> Void
|
Parent Package: demographic
Class PARTY{Abstract}
LOCATABLE
| +--PARTY
Direct Subclassifiers:
ACTOR, ROLE
Ancestor of all party types, including real world entities and their roles. A party is any entity which can participate in an activity. The name attribute inherited from LOCATABLE is used to indicate the actual type of party (note that the actual names, i.e. identities of parties are indicated in the identities attribute, not the name attribute).
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
details : ITEM_STRUCTURE | 0..1 | -- | | All other details for this party. |
reverse_relationships : Set<LOCATABLE_REF> | 0..1 | -- | | Relationships in which this role takes part as target. |
uid : HIER_OBJECT_ID | 1 | -- | | (Redefined from LOCATABLE). Identifier of this Party |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| identities : Set<PARTY_IDENTITY> | 1 | 1..* | Identities used by the party to identify itself, such as legal name, stage names, aliases, nicknames and so on. |
| contacts : Set<CONTACT> | 0..1 | 0..* | Contacts for this party. |
| relationships : Set<PARTY_RELATIONSHIP> | 0..1 | 0..* | Relationships in which this role takes part as source. |
| Operations |
| Signature | Constraints | Documentation |
type()
:
DV_TEXT | | Type of party, such as “PERSON”, “ORGANISATION”, etc. Role name, e.g. “general practitioner”, “nurse”, “private citizen”. Taken from inherited name attribute. |
| Constraints |
| Name | Expression |
| No_parent | inv: parent = Void |
| Reverse_relationships_validity | inv: reverse_relationships <> Void implies (not
reverse_relationships.empty and reverse_relationships.for_all(repository('demographics').all_party_relationships.has_object(item) and repository('demographics').all_party_relationships.object(item).target = Current)) |
| Identities_valid | inv: identities <> Void and not identities.empty |
| Is_archetype_root | inv: is_archetype_root |
| Contacts_valid | inv: contacts <> Void implies not contacts.empty |
| Relationships_validity | inv: relationships <> Void implies (not relationships.empty
and relationships.for_all({PARTY_RELATIONSHIP}.source = Current)) |
| Type_valid | inv: type = name |
| Uid_valid | inv: uid <> Void |
Parent Package: demographic
Class CONTACT
LOCATABLE
| +--CONTACT
Description of a means of contact of a party. Actual structure is archetyped.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
time_validity : DV_INTERVAL<DV_DATE> | 0..1 | -- | | Valid time interval for this contact descriptor. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| addresses : Set<ADDRESS> | 1 | 1..* | A set of address alternatives for this purpose and time validity. |
| Operations |
| Signature | Constraints | Documentation |
purpose()
:
DV_TEXT | | Purpose for which this contact is used, e.g. “mail”, “daytime phone”, etc. Taken from value of inherited name attribute. |
| Constraints |
| Name | Expression |
| Addresses_exists | inv: addresses <> Void and not addresses.empty |
| Purpose_valid | inv: purpose = name |
Parent Package: demographic
Class ADDRESS
LOCATABLE
| +--ADDRESS
Address of contact, which may be electronic or geographic.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
details : ITEM_STRUCTURE | 1 | -- | | The details of the address, in the form of a STRUCTURE. This may take the form of an ITEM_LIST, whose data item is a parsable string or a list or tree of many parts. |
| Operations |
| Signature | Constraints | Documentation |
as_string()
:
String | | Address in the form of a single string. |
type()
:
DV_TEXT | | Type of address, e.g. “electronic”, “locality”. Taken from value of inherited name attribute. |
| Constraints |
| Name | Expression |
| Type_valid | inv: type = name |
| Details_exists | inv: details <> Void |
Parent Package: demographic
Class ACTOR{Abstract}
PARTY
| +--ACTOR
Direct Subclassifiers:
AGENT, ORGANISATION, PERSON, GROUP
Ancestor of all real-world types, including people and organisations. An actor is any real-world entity capable of taking on a role.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
languages : List<DV_TEXT> | 0..1 | -- | | Languages which can be used to communicate with this actor, in preferred order of use (if known, else order irrelevant). |
roles : Set<PARTY_REF> | 0..1 | -- | | Identifiers of the Version container for each Role played by this party. |
| Operations |
| Signature | Constraints | Documentation |
has_legal_identity()
:
Boolean | | True if one there is an identity with purpose “legal identity” |
| Constraints |
| Name | Expression |
| Roles_valid | inv: roles <> Void implies not roles.is_empty |
| Legal_identity_existsamed3 | inv: has_legal_identity |
| Languages_valid | inv: languages <> Void implies not languages.is_empty |
Parent Package: demographic
Class ROLE
PARTY
| +--ROLE
Generic description of a role performed by an actor. The role corresponds to a competency of the party. Roles are used to define the responsibilities undertaken by a party for a purpose. Roles should have credentials qualifying the performer to perform the role.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
performer : PARTY_REF | 1 | -- | | Reference to Version container of Actor playing the role. |
time_validity : DV_INTERVAL<DV_DATE> | 0..1 | -- | | Valid time interval for this role. |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| capabilities : Set<CAPABILITY> | 0..1 | 0..* | The capabilities of this role. |
| Constraints |
| Name | Expression |
| Capabilities_valid | inv: capabilities <> Void implies not capabilities.empty |
| Performer_exists | inv: performer <> Void |
Parent Package: demographic
Class PARTY_IDENTITY
LOCATABLE
| +--PARTY_IDENTITY
An identity “owned” by a PARTY, such as a person name or company name, and
which is used by the party to identify itself. Actual structure is archetyped.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
details : ITEM_STRUCTURE | 1 | -- | | The value of the indentity. This will often taken the form of a parsable string or a small structure of strings. |
| Operations |
| Signature | Constraints | Documentation |
as_string()
:
String | | Indentity in the form of a single string. |
purpose()
:
DV_TEXT | | Purpose of identity, e.g. “legal”, “stagename”, “nickname”, “tribal name”, “trading name”. Taken from value of inherited name attribute. |
| Constraints |
| Name | Expression |
| Purpose_valid | inv: purpose = name |
| Details_exists | inv: details <> Void |
Parent Package: demographic
Class CAPABILITY
LOCATABLE
| +--CAPABILITY
Capability of a role, such as “ehr modifier”, “health care provider”. Capability should be backed up by credentials.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
credentials : ITEM_STRUCTURE | 1 | -- | | The qualifications of the performer of the role for this capability. This might include professional qualifications and official identifications such as provider numbers etc. |
time_validity : DV_INTERVAL<DV_DATE> | 0..1 | -- | | Valid time interval for the credentials of this capability. |
| Constraints |
| Name | Expression |
| Credentials_exists | inv: credentials <> Void |
Parent Package: demographic
Class AGENT
ACTOR
| +--AGENT
Generic concept of any kind of agent, including devices, software systems, but not humans or organisations.
Parent Package: demographic
Class ORGANISATION
ACTOR
| +--ORGANISATION
Generic description of organisations. An organisation is a legally constituted body whose existence (in general) outlives the existence of parties considered to be part of it.
Parent Package: demographic
Class GROUP
ACTOR
| +--GROUP
A group is a real world group of parties which is created by another party, usually an organisation, for some specific purpose. A typical clinical example is that of the specialist care team, e.g. “cardiology team”. The members of the group usually work together.
Parent Package: demographic
Class PERSON
ACTOR
| +--PERSON
Generic description of persons. Provides a dedicated type to which Person archetypes can be targeted.
Parent Package: demographic
Class VERSIONED_PARTY
Parent Package: rm
Package :: ehr
Parent Package: ehr
Class EHR
The EHR object is the root object and access point of an EHR for a subject of care.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
compositions : List<OBJECT_REF> | 0..1 | -- | | Master list of all composition references in this EHR |
contributions : List<OBJECT_REF> | 1 | -- | | List of contributions causing changes to this EHR. Each contribution contains a list of versions, which may include references to any number of VERSION instances, i.e. items of type VERSIONED_COMPOSITION and VERSIONED_FOLDER. |
directory : OBJECT_REF | 0..1 | -- | | Optional directory structure for this EHR. |
ehr_access : OBJECT_REF | 1 | -- | | Reference to EHR_ACCESS object for this EHR. |
ehr_id : HIER_OBJECT_ID | 1 | -- | | The id of this EHR. |
ehr_status : OBJECT_REF | 1 | -- | | Reference to EHR_STATUS object for this EHR. |
system_id : HIER_OBJECT_ID | 1 | -- | | The id of the EHR system on which this EHR was created. |
time_created : DV_DATE_TIME | 1 | -- | | Time of creation of the EHR |
| Constraints |
| Name | Expression |
| Directory_valid | inv: directory <> Void implies directory.
type.is_equal('VERSIONED_FOLDER') |
| Ehr_id_valid | inv: ehr_id <> Void |
| Contributions_valid | inv: contributions <> Void and contributions.
for_all(type.is_equal('CONTRIBUTION')) |
| System_id_valid | inv: system_id <> Void |
| Time_created_valid | inv: time_created <> Void |
| Compositions_valid | inv: compositions <> Void and compositions.for_all(type.is_equal('VERSIONED_COMPOSITION')) |
| Ehr_status_valid | inv: ehr_status <> Void and ehr_status.type.is_equal('VERSIONED_EHR_STATUS') |
| Ehr_acces_valid | inv: ehr_access <> Void and ehr_access.type.is_equal('VERSIONED_EHR_ACCESS') |
Parent Package: ehr
Class VERSIONED_COMPOSITION
Version-controlled composition abstraction, defined by inheriting VERSIONED_OBJECT.
| Operations |
| Signature | Constraints | Documentation |
is_persistent()
:
Boolean | | Indicates whether this composition set is persistent; derived from first version. |
| Constraints |
| Name | Expression |
| Archetype_node_id_valid | inv: all_versions.for_all
(archetype_node_id.is_equal(all_versions.first.archetype_node_id))
|
| Persistent_valid | inv: all_versions.for_all (is_persistent =
all_versions.first.data.is_persistent) |
| Owner_id_valid | inv: owner_id.generating_type.is_equal('EHR') |
Parent Package: ehr
Class VERSIONED_EHR_STATUS
Versioning container for EHR_STATUS instance.
Parent Package: ehr
Class EHR_STATUS
LOCATABLE
| +--EHR_STATUS
Single object per EHR giving various EHR-wide information.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
is_modifiable : Boolean | 1 | -- | | True if this EHR is allowed to be written to. |
is_queryable : Boolean | 1 | -- | | True if this EHR should be included in population queries, i.e. if this EHR is considered active in the population. |
other_details : ITEM_STRUCTURE | 0..1 | -- | | Any other details of the EHR summary object, in the form of an archetyped Item_structure. |
subject : PARTY_SELF | 1 | -- | | The subject of this EHR. The external_ref attribute can be used to contain a direct reference to the subject in a demographic or identity service. Alternatively, the association between patients and their records may be done elsewhere for security reasons. |
| Constraints |
| Name | Expression |
| Is_archetype_root | inv: is_archetype_root
|
| Subject_valid | inv: subject /= Void
|
| No_parent | inv: parent = Void |
Parent Package: ehr
Class EHR_ACCESS
LOCATABLE
| +--EHR_ACCESS
EHR-wide access contol object. All access decisions to data in the EHR must be made in accordance with the policies and rules in this object.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
settings : ACCESS_CONTROL_SETTINGS | 1 | -- | | Access control settings for the EHR. Instance is a subtype of the type ACCESS_CONTROL_SETTINGS, allowing for the use of different access control schemes. |
| Operations |
| Signature | Constraints | Documentation |
scheme()
:
String | | The name of the access control scheme in use; corresponds to the concrete instance of the settings attribute. |
| Constraints |
| Name | Expression |
| Scheme_exists | inv: scheme <> void and not scheme.is_empty |
Parent Package: ehr
Class VERSIONED_EHR_ACCESS
Parent Package: rm
Package :: integration
Parent Package: integration
Class GENERIC_ENTRY
CONTENT_ITEM
| +--GENERIC_ENTRY
Parent Package: rm
Package :: security
Security Information Model Placeholder
Parent Package: security
Package :: access_control
Parent Package: rm
Package :: support
Parent Package: support
Class EXTERNAL_ENVIRONMENT_ACCESS{Abstract}
MEASUREMENT_SERVICE, TERMINOLOGY_SERVICE
| +--EXTERNAL_ENVIRONMENT_ACCESS
A mixin class providing access to services in the external environment.
| Operations |
| Signature | Constraints | Documentation |
eea_measurement_svc()
:
MEASUREMENT_SERVICE | | Return an interface to the measurement service |
eea_terminology_svc()
:
TERMINOLOGY_SERVICE |
inv: eea_terminology_svc /= Void | Return an interface to the terminology service |
| Constraints |
| Name | Expression |
| Terminology_service_exists | inv: eea_terminology_svc <> Void |
| Measurement_service_exists | inv: eea_measurement_svc <> Void |
Parent Package: support
Package :: definition
The definition package describes symbolic definitions used by the openEHR models.
Parent Package: definition
Class BASIC_DEFINITIONS
Direct Subclassifiers:
OPENEHR_DEFINITIONS, DATA_VALUE
Defines globally-used constant values.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
CR : | 1 | -- | '\015' | Carriage return character |
LF : | 1 | -- | '\012' | Linefeed character |
Parent Package: definition
Class OPENEHR_DEFINITIONS
BASIC_DEFINITIONS
| +--OPENEHR_DEFINITIONS
Inheritance class to provide access to constants defined in other packages.
Parent Package: support
Package :: identification
The identification package describes a model of references and identifiers for information entities only. Real-world entity identifiers are defined in the openEHR Data Types information model.
Parent Package: identification
Class OBJECT_REF
Direct Subclassifiers:
LOCATABLE_REF, PARTY_REF, ACCESS_GROUP_REF
Class describing a reference to another object, which may exist locally or be maintained outside the current namespace, e.g. in another service. Services are usually external, e.g. available in a LAN (including on the same host) or the internet via Corba, SOAP, or some other distributed protocol. However, in small systems they may be part of the same executable as the data containing the Id.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
namespace : String | 1 | -- | | the local system context (and possibly in any other openEHR compliant environment) e.g.
“terminology”, “demographic”. These names are not yet standardised. Legal values for the
namespace are “local” | “unknown” | “[a-zAZ][ a-zA-Z0-9_-:/&+?]*” |
type : String | 1 | -- | | Name of the class of object to which this identifier type refers, e.g. “PARTY”, “PERSON”,
“GUIDELINE” etc. These class names are from the relevant reference model.
The type name “ANY” can be used to indicate that any type is accepted (e.g. if the type is unknown). |
| Attributes from Associations |
| | Signature | Optionality | Multiplicity | Documentation |
| id : OBJECT_ID | 1 | -- | Globally unique id of an object, regardless of where it is stored. |
| Constraints |
| Name | Expression |
| Namespace_exists | inv: namespace <> Void and not namespace.empty |
| Type_exists | inv: type <> Void and not type.empty |
| Id_exists | inv: id <> Void |
Parent Package: identification
Class OBJECT_ID
Direct Subclassifiers:
ARCHETYPE_ID, TERMINOLOGY_ID, GENERIC_ID, UID_BASED_ID, TEMPLATE_ID
Ancestor class of identifiers of informational objects. Ids may be completely meaningless, in which case their only job is to refer to something, or may carry some information to do with the identified object.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
value : String | 1 | -- | | The value of the id in the form “::” . |
| Constraints |
| Name | Expression |
| Value_exists | inv: value <> Void and not value.empty |
Parent Package: identification
Class UID{Abstract}
Direct Subclassifiers:
INTERNET_ID, UUID, ISO_OID
Abstract parent of classes representing unique identifiers which identify information entities in a durable way. UIDs only ever identify one IE in time or space andare never re-used.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
value : String | 1 | -- | | |
| Constraints |
| Name | Expression |
| Value_exists | inv: value <> Void and not value.empty |
Parent Package: identification
Class ACCESS_GROUP_REF
OBJECT_REF
| +--ACCESS_GROUP_REF
Reference to access group in an access control service.
| Constraints |
| Name | Expression |
| Type_validity | inv: type.is_equal('ACCESS_GROUP') |
Parent Package: identification
Class HIER_OBJECT_ID
UID_BASED_ID
| +--HIER_OBJECT_ID
Hierarchical identifiers consisting of a root part and an optional extension.
| Constraints |
| Name | Expression |
| Extension_valid | inv: has_extension xor extension = Void |
| Root_valid | inv: root <> Void |
Parent Package: identification
Class TERMINOLOGY_ID
OBJECT_ID
| +--TERMINOLOGY_ID
Identifier for terminologies such accessed via a terminology query service. In this class, the value attribute identifies the Terminology in the terminology service, e.g. “SNOMED-CT”. A terminology is assumed to be in a particular language, which must be explicitly specified.
The value if the id attribute is the precise terminology id identifier, including actual release (i.e. actual “version”), local modifications etc; e.g. “ICPC2”
| Operations |
| Signature | Constraints | Documentation |
name()
:
String | | Return the terminology id (which includes the “version” in some cases). Distinct names correspond to distinct (i.e. non-compatible) terminologies.
Thus the names “ICD10AM” and “ICD10” refer to distinct terminologies. |
version_id()
:
String | | Version of this terminology, if versioning supported, else the empty string. |
| Constraints |
| Name | Expression |
| Version_id_valid | inv: version_id <> Void |
| Name_valid | inv: name <> Void and not name.is_empty |
Parent Package: identification
Class UUID
UID
| +--UUID
Model of the DCE Universal Unique Identifier or UUID which takes the form of hexadecimal integers separated by hyphens, following the pattern 8-4-4-4-12 as defined by the Open Group, CDE 1.1 Remote Procedure Call specification, Appendix A. Also known as a GUID.
Parent Package: identification
Class ISO_OID
UID
| +--ISO_OID
Model of ISO’s Object Identifier (oid) as defined by the standard ISO/IEC 8824 .
Oids are formed from integers separated by dots. Each non-leaf node in an Oid starting from the left corresponds to an assigning authority, and identifies that authority’s namespace, inside which the remaining part of the identifier is locally unique.
Parent Package: identification
Class PARTY_REF
OBJECT_REF
| +--PARTY_REF
Identifier for parties in a demographic or identity service. There are typically a number of subtypes of the PARTY class, including PERSON, ORGANISATION, etc.
| Constraints |
| Name | Expression |
| Type_validity | inv: type.is_equal('PERSON') or
type.is_equal('ORGANISATION') or
type.is_equal('GROUP') or
type.is_equal('AGENT')or
type.is_equal('ROLE') or
type.is_equal('PARTY') or
type.is_equal('ACTOR')
|
Parent Package: identification
Class ARCHETYPE_ID
OBJECT_ID
| +--ARCHETYPE_ID
Identifier for archetypes.
| Operations |
| Signature | Constraints | Documentation |
domain_concept()
:
String | | Name of the concept represented by this archetype, including specialisation, e.g. “biochemistry result-cholesterol”. |
qualified_rm_entity()
:
String | | Globally qualified reference model entity, e.g. “openehr-ehr_rm-entry”. |
rm_entity()
:
String | | Name of the ontological level within the reference model to which this archetype is targeted,
e.g. for openEHR, “folder”, “composition”, “section”, “entry”. |
rm_name()
:
String | | Name of the reference model, e.g. “rim”, “ehr_rm”, “en13606”. |
rm_originator()
:
String | | Organisation originating the reference model on which this archetype is based, e.g. “openehr”, “cen”, “hl7”. |
specialisation()
:
String | | Name of specialisation of concept, if this archetype is a specialisation of another archetype, e.g. “cholesterol”. |
version_id()
:
String | | Version of this archetype. |
| Constraints |
| Name | Expression |
| Rm_name_valid | inv: rm_name <> Void and not rm_name.is_empty
|
| Rm_entity_valid | inv: rm_entity <> Void and not rm_entity.is_empty
|
| Domain_concept_valided2 | inv: domain_concept <> Void and not
domain_concept.is_empty
|
| Qualified_rm_entity_valid | inv: qualified_rm_entity <> Void and not
qualified_rm_entity.is_empty
|
| Version_id_valid | inv: version_id <> Void and not version_id.is_empty |
| Rm_originator_valid | inv: rm_originator <> Void and not
rm_originator.is_empty
|
| Specialisation_valid | inv: specialisation <> Void implies not specialisation.is_empty
|
Parent Package: identification
Class LOCATABLE_REF
OBJECT_REF
| +--LOCATABLE_REF
Reference to a LOCATABLE instance inside the top-level content structure inside a VERSION; the path attribute is applied to the object that VERSION.data points to.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
path : String | 0..1 | -- | | The path to an instance in question, as an absolute path with respect to the object found at ERSION.data. An empty path means that the object referred to by id being specified. |
| Operations |
| Signature | Constraints | Documentation |
as_uri()
:
String | | A URI form of the reference, created by concatenating the following:
“ehr://” + id.value + “/” + path |
| Constraints |
| Name | Expression |
| Path_valid | inv: path <> Void implies not path.is_empty |
Parent Package: identification
Class INTERNET_ID
UID
| +--INTERNET_ID
Model of a reverse internet domain, as used to uniquely identify an internet domain. In the form of a dot-separated string in the reverse order of a domain name, specified by IETF RFC 1034
(http://www.ietf.org/rfc/rfc1034.txt).
Parent Package: identification
Class OBJECT_VERSION_ID
UID_BASED_ID
| +--OBJECT_VERSION_ID
Globally unique identifier for one version of a versioned object.
| Operations |
| Signature | Constraints | Documentation |
creating_system_id()
:
HIER_OBJECT_ID | | Identifier of the system that created the Version corresponding to this Object version id. |
is_branch()
:
Boolean | | True if this identifier represents a branch. |
object_id()
:
UID | | Unique identifier for logical object of which this identifier identifies one version; normally the object_id will be the unique identifier of the version container containing the version referred to by this OBJECT_VERSION_ID instance. |
version_tree_id()
:
VERSION_TREE_ID | | Tree identifier of this version with respect to other versions in the same version tree, as either 1 or 3 part dot-separated numbers, e.g. “1”, “2.1.4”. |
| Constraints |
| Name | Expression |
| Version_tree_id | inv: version_tree_id <> Void |
| Object_valid | inv: object_id <> Void |
| creating_system_id | inv: creating_system_id <> Void |
Parent Package: identification
Class VERSION_TREE_ID
Version tree identifier for one version.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
value : String | 1 | -- | | |
| Operations |
| Signature | Constraints | Documentation |
branch_number()
:
String | | Number of branch from the trunk point. |
branch_version: String()
:
| | |
is_branch()
:
Boolean | | True if this version identifier represents a branch, i.e. has branch_number and branch_version parts. |
trunk_version()
:
String | | Trunk version number. |
| Constraints |
| Name | Expression |
| Is_branch_validity | inv: is_branch xor branch_version = Void |
| Trunk_version_valid | inv: trunk_version <> Void and trunk_version.is_integer and trunk_version.as_integer >= 1 |
| Branch_validity | inv: (branch_number = Void and branch_version = Void ) xor
(branch_number <> Void and branch_version <> Void ) |
| Branch_version_valid | inv: branch_version <> Void implies
branch_version.is_integer and branch_version.as_integer >= 1 |
| Value_valid | inv: value <> Void and not value.is_empty |
| Branch_number_valid | inv: branch_number <> Void and
branch_number.is_integer |
| Is_first_validity | inv: not is_first xor trunk_version.is_equal('1') |
Parent Package: identification
Class GENERIC_ID
OBJECT_ID
| +--GENERIC_ID
Generic identifier type for identifiers whose format is othterwise unknown to openEHR. Includes an attribute for naming the identification scheme (which may well be local).
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
scheme : String | 1 | -- | | Name of the scheme to which this identifier conforms. Ideally this name will be recognisable
globally but realistically it may be a local ad hoc scheme whose name is not controlled or standardised in any way. |
| Constraints |
| Name | Expression |
| Scheme_valid | inv: scheme <> Void and not scheme.is_empty |
Parent Package: identification
Class UID_BASED_ID
OBJECT_ID
| +--UID_BASED_ID
Direct Subclassifiers:
OBJECT_VERSION_ID, HIER_OBJECT_ID
Abstract model of UID-based identifiers consisting of a root part and an optional
extension; lexical form:
root ‘::’ extension
| Operations |
| Signature | Constraints | Documentation |
extension()
:
String | | Optional local identifier of the object within the context of the root identifier.
Returns the part to the left of the first ‘::’ separator if any, or else any empty String. |
has_extension()
:
Boolean | | True if there is an extension part. |
root()
:
UID | | The identifier of the conceptual namespace in which the object exists, within the identification
scheme.
Returns the part to the left of the first ‘::’ separator, if any, or else the whole string. |
Parent Package: identification
Class TEMPLATE_ID
OBJECT_ID
| +--TEMPLATE_ID
Identifier for templates. Lexical form to be determined.
Parent Package: support
Package :: measurement
Parent Package: measurement
Class MEASUREMENT_SERVICE
Direct Subclassifiers:
EXTERNAL_ENVIRONMENT_ACCESS
Defines an object providing proxy access to a measurement information service.
| Operations |
| Signature | Constraints | Documentation |
is_valid_units_string(units : String)
:
Boolean |
pre: units <> Void | True if the units string ‘units’ is a valid string according to the HL7 UCUM specification. |
units_equivalent(units1,units2 : String)
:
Boolean |
pre: units1 <> Void and
is_valid_units_string(units1)
pre: units2 <> Void and
is_valid_units_string(units2) | True if two units strings correspond to the same measured property. |
Parent Package: support
Package :: terminology
This describes the terminology package, which contains classes for accessing the openEHR support terminology from within instances of classes defined in the reference model.
Parent Package: terminology
Class TERMINOLOGY_ACCESS
Defines an object providing proxy access to a terminology.
| Operations |
| Signature | Constraints | Documentation |
all_codes()
:
Set<CODE_PHRASE> | | Return all codes known in this terminology |
codes_for_group_id(group_id : String)
:
Set<CODE_PHRASE> | | Return all codes under grouper ‘group_id’ from this terminology |
codes_for_group_name(name, lang : String)
:
Set<CODE_PHRASE> | | Return all codes under grouper whose name in ‘lang’ is ‘name’ from this terminology |
has_code_for_group_id(group_id : String, a_code : String)
:
Boolean | | True if ‘a_code’ is known in group ‘group_id’ in the openEHR terminology. |
id()
:
String | | Identification of this Terminology |
rubric_for_code(code, lang : String)
:
String | | Return all rubric of code ‘code’ in language ‘lang’. |
| Constraints |
| Name | Expression |
| id_exists: | inv:id <> Void and not id.is_empty |
Parent Package: terminology
Class CODE_SET_ACCESS
Defines an object providing proxy access to a code_set.
| Operations |
| Signature | Constraints | Documentation |
all_codes()
:
Set<CODE_PHRASE> | | Return all codes known in this code set |
has_code(a_code : CODE_PHRASE)
:
Boolean | | True if code set knows about ‘a_code’ |
has_lang(a_lang : CODE_PHRASE)
:
Boolean | | True if code set knows about ‘a_lang’ |
id()
:
String | | External identifier of this code set |
| Constraints |
| Name | Expression |
| id_exists: | inv:id <> Void and not id.is_empty |
Parent Package: terminology
Class OPENEHR_TERMINOLOGY_GROUP_IDENTIFIERS
Direct Subclassifiers:
TERMINOLOGY_SERVICE
List of identifiers for groups in the openEHR terminology.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
Group_id_attestation_reason : String | 1 | -- | 'attestation reason' | |
Group_id_audit_change_type : String | 1 | -- | 'audit change type' | |
Group_id_composition_category : String | 1 | -- | 'composition category' | |
Group_id_event_math_function : String | 1 | -- | 'event math function' | |
Group_id_instruction_states : String | 1 | -- | 'instruction states' | |
Group_id_instruction_transitions : String | 1 | -- | 'instruction transitions' | |
Group_id_null_flavours : String | 1 | -- | 'null flavours' | |
Group_id_participation_function : String | 1 | -- | 'participation function' | |
Group_id_participation_mode : String | 1 | -- | 'participation mode' | |
Group_id_property : String | 1 | -- | 'property' | |
Group_id_setting : String | 1 | -- | 'setting' | |
Group_id_subject_relationship : String | 1 | -- | 'subject relationship' | |
Group_id_term_mapping_purpose : String | 1 | -- | 'term mapping purpose' | |
Group_id_version_lifecycle_state : String | 1 | -- | 'version lifecycle state' | |
Terminology_id : String | 1 | -- | 'openehr' | |
Parent Package: terminology
Class OPENEHR_TERMINOLOGY_CODE_SET_IDENTIFIERS
Direct Subclassifiers:
TERMINOLOGY_SERVICE
List of identifiers for code sets in the openEHR terminology.
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
Code_set_id_character_sets : String | 1 | -- | 'character sets' | |
Code_set_id_compression_algorithms : String | 1 | -- | 'compression algorithms' | |
Code_set_id_countries : String | 1 | -- | 'countries' | |
Code_set_id_integrity_check_algorithms : String | 1 | -- | 'integrity check algorithms' | |
Code_set_id_languages : String | 1 | -- | 'languages' | |
Code_set_id_media_types : String | 1 | -- | 'media_types' | |
Code_set_id_normal_statuses : String | 1 | -- | 'normal statuses' | |
| Operations |
| Signature | Constraints | Documentation |
valid_code_set_id(an_id : String)
:
Boolean | | Validity function to test if an id is in the set defined by this class. |
Parent Package: terminology
Class TERMINOLOGY_SERVICE
OPENEHR_TERMINOLOGY_CODE_SET_IDENTIFIERS, OPENEHR_TERMINOLOGY_GROUP_IDENTIFIERS
| +--TERMINOLOGY_SERVICE
Direct Subclassifiers:
EXTERNAL_ENVIRONMENT_ACCESS
Defines an object providing proxy access to a terminology service.
| Operations |
| Signature | Constraints | Documentation |
code_set(name : String)
:
CODE_SET_ACCESS |
pre: name <> Void and has_code_set (name) post: Result <> Void |
Return an interface to the code_set identified
by the external identifier name
(e.g. “ISO_639-1”).
|
code_set_for_id(id : String)
:
CODE_SET_ACCESS |
pre: id <> Void and
valid_code_set_id (id) post: Result <> Void |
Return an interface to the code_set identified internally in
openEHR by id.
|
code_set_identifiers()
:
List<String> | | Set of all code set identifiers known in the terminology service. |
has_code_set(name : String)
:
String |
pre: name <> Void and not name.is_empty | True if code_set linked to internal name (e.g. “languages”) is available. |
has_terminology(name : String)
:
Boolean |
pre: name <> Void and not name.is_empty |
True if terminology named ‘name’ known by this service.Allowable
names include
•“openehr”
•“centc251”
•any name from are taken from the US NLM UMLS meta-data list
at
http://www.nlm.nih.gov/research/umls/metaa1.html
|
openehr_code_sets()
:
Hash<String,String> | | Set of all code sets identifiers for which there is an internal openEHR name;
returned as a Hash of ids keyed by internal name. |
terminology(name : String)
:
TERMINOLOGY_ACCESS |
pre: name <> Void and has_terminology (name) post: Result <> Void |
Return an interface to the terminology named name. Allowable
names include
•“openehr”
•“centc251”
•any name from are taken from the US NLM UMLS meta-data list
at
http://www.nlm.nih.gov/research/umls/metaa1.html
|
terminology_identifiers()
:
List<String> | |
Set of all terminology identifiers known in the terminology
service. Values from the US NLM UMLS meta-data list at
http://www.nlm.nih.gov/research/umls/metaa1.html
|
Package :: sm
Parent Package: sm
Class QUERY
| Operations |
| Signature | Constraints | Documentation |
create()
:
| | |
execute()
:
| | |
Parent Package: sm
Class QUERY_ITEM
Direct Subclassifiers:
QUERY_LEAF, QUERY_NODE
Parent Package: sm
Class QUERY_NODE
QUERY_ITEM
| +--QUERY_NODE
Direct Subclassifiers:
BINARY_QUERY_NODE, UNARY_QUERY_NODE
| Attributes |
| Signature | Optionality | Multiplicity | Constant | Documentation |
operator : String | 1 | -- | | |
Parent Package: sm
Class UNARY_QUERY_NODE
QUERY_NODE
| +--UNARY_QUERY_NODE
Parent Package: sm
Class BINARY_QUERY_NODE
QUERY_NODE
| +--BINARY_QUERY_NODE
Parent Package: sm
Class QUERY_LEAF
QUERY_ITEM
| +--QUERY_LEAF
Package :: TypesUML
This package contains the UML representation and semantics of assumed data types.
It overcomes the inability of UML to represent O-O generic types properly.
Parent Package: TypesUML
Class Any{Abstract}
Direct Subclassifiers:
Interval, Aggregate, TIME_DEFINITIONS
| Operations |
| Signature | Constraints | Documentation |
equal(other : Any)
:
Boolean | | |
instance_of(a_type : String)
:
| | |
is_equal(other : Any)
:
Boolean | | Value equality |
TypesUML
Data Type Interval<Duration>
| General Info
|
| Name | Interval<Duration> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Data Type Interval<Date>
TypesUML
Data Type Date_Time
TypesUML
Data Type Duration
TypesUML
Data Type Date
TypesUML
Data Type Hash<String,String>
| General Info
|
| Name | Hash<String,String> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Data Type Interval<Date_Time>
| General Info
|
| Name | Interval<Date_Time> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Data Type Set<CODE_PHRASE>
| General Info
|
| Name | Set<CODE_PHRASE> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Primitive Character
Any
| +--Character
TypesUML
Data Type List<C_OBJECT>
TypesUML
Data Type Interval<Time>
TypesUML
Primitive List<OBJECT_VERSION_ID>
| General Info
|
| Name | List<OBJECT_VERSION_ID> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Primitive Set<LOCATABLE_REF>
| General Info
|
| Name | Set<LOCATABLE_REF> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Data Type Set<Real>
TypesUML
Primitive Ordered
Any
| +--Ordered
Direct Subclassifiers:
Ordered_Numeric
Abstract notional parent class of ordered, types i.e. types on which the ‘<‘ operator
is defined.
| Operations |
| Signature | Constraints | Documentation |
infix('<' : Character, other : Ordered)
:
Boolean | | Arithmetic comparison. In conjunction with ‘=’, enables the definition of the operators ‘>’, ‘>=’, ‘<=’, ‘<>’.
In real type systems, this operator might be defined on another class for comparability. |
TypesUML
Data Type Interval<Real>
TypesUML
Data Type Time
TypesUML
Primitive Ordered_Numeric
Any, Ordered, Numeric
| +--Ordered_Numeric
Direct Subclassifiers:
Double, Integer, Real
Abstract notional parent class of ordered, numeric types, which are types with ‘<‘
and arithmetic operators defined
TypesUML
Primitive Integer
Ordered_Numeric
| +--Integer
TypesUML
Data Type List<VERSION>
TypesUML
Data Type Set<String>
TypesUML
Primitive Numeric
Any
| +--Numeric
Direct Subclassifiers:
Ordered_Numeric
Abstract notional parent class of numeric types, which are types which have various
arithmetic and comparison operators defined.
| Operations |
| Signature | Constraints | Documentation |
infix('*' : Character, other : Numeric)
:
Numeric |
pre: other <> void post: Result <> void | Product by `other'. Actual type of result depends on arithmetic balancing rules. |
infix('+' : Character, other : Numeric)
:
Numeric |
pre: other <> void post: Result <> void post: equal (Result, other + Current) | Sum with `other' (commutative).
Actual type of result depends on arithmetic balancing rules. |
infix('-' : Character, other : Numeric)
:
Numeric |
pre: other <> void post: Result <> void | Result of subtracting `other'. Actual type of result depends on arithmetic balancing rules. |
TypesUML
Data Type U
TypesUML
Primitive List<OBJECT_REF>
| General Info
|
| Name | List<OBJECT_REF> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Primitive Double
Ordered_Numeric
| +--Double
TypesUML
Primitive Set<PARTY_REF>
TypesUML
Data Type List<ELEMENT>
TypesUML
Primitive Interval<T>
Any
| +--Interval<T>
TypesUML
Data Type List<DV_TEXT>
TypesUML
Data Type List<String>
TypesUML
Primitive Real
Ordered_Numeric
| +--Real
Type used to represent decimal numbers. Typically corresponds to a single-precision
floating point value in most languages.
| Operations |
| Signature | Constraints | Documentation |
floor()
:
Integer | | Return the greatest integer no greater than the value of this object. |
TypesUML
Data Type Interval<Integer>
| General Info
|
| Name | Interval<Integer> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Primitive Boolean
Any
| +--Boolean
Boolean type used for two-valued mathematical logic.
| Operations |
| Signature | Constraints | Documentation |
infix('and' : String, other : Boolean)
:
Boolean |
pre: other <> void post: Result = not (not Current
and not other) post: Result = (other and Current) | Logical conjunction |
infix('and then' : String, other : Boolean)
:
Boolean |
post: Result = not (not Current
or not other) pre: other <> void | Boolean semi-strict conjunction with other |
infix('or' : String, other : Boolean)
:
Boolean |
post: Result = not (not Current
and not other) post: Result
implies (Current or other) pre: other <> void post: Result = (other and Current) | Boolean disjunction with other |
infix('or else' : String, other : Boolean)
:
Boolean |
post: Result = not (not Current
and not other) pre: other <> void | Boolean semi-strict disjunction with `other' |
infix('xor' : String, other : Boolean)
:
Boolean | | Boolean exclusive or with `other' |
infix('implies' : String, other : Boolean)
:
|
post: Result = (not Current or other) pre: other <> void | Boolean implication of `other' (semistrict) |
| Constraints |
| Name | Expression |
| involutive_negation | inv: is_equal (not (not Current))
|
| non_contradictiond2 | inv: not (Current and (not Current))
|
| completeness | inv: Current or (not Current) |
TypesUML
Data Type Set<Integer>
TypesUML
Primitive Set<DV_EHR_URI>
| General Info
|
| Name | Set<DV_EHR_URI> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Primitive List<DV_IDENTIFIER>
| General Info
|
| Name | List<DV_IDENTIFIER> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Primitive Any
Direct Subclassifiers:
Numeric, String, Ordered, Character, Ordered_Numeric, Octet, Boolean, Interval<T>
Abstract supertype. Usually maps to a type like “Any” or “Object” in an object
system. Defined here to provide the value and reference equality semantics.
| Operations |
| Signature | Constraints | Documentation |
equal(other : Any)
:
Boolean | | |
instance_of(a_type : String)
:
| | Dynamic type of object as a String.
Used for type name matching. |
is_equal(other : Any)
:
Boolean | | Value equality |
TypesUML
Primitive Set<OBJECT_VERSION_ID>
| General Info
|
| Name | Set<OBJECT_VERSION_ID> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Primitive List<REFERENCE_RANGE>
| General Info
|
| Name | List<REFERENCE_RANGE> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Data Type DV_INTERVAL<DV_DATE>
| General Info
|
| Name | DV_INTERVAL<DV_DATE> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Data Type List<PARTICIPATION>
| General Info
|
| Name | List<PARTICIPATION> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Primitive Octet
Any
| +--Octet
TypesUML
Primitive Array<Octet>
TypesUML
Primitive List<CLUSTER>
TypesUML
Primitive String
Any
| +--String
Strings of characters, as used to represent textual data in any natural or formal language.
| Operations |
| Signature | Constraints | Documentation |
as_integer()
:
Integer |
pre: is_integer | Return the integer corresponding to the integer value represented in this string. |
infix('+' : Character, other : String)
:
String | | Concatenation operator - causes ‘other’ to be appended to this string |
is_empty()
:
Boolean | | True if string is empty, i.e. equal to “”. |
is_integer()
:
Boolean | | True if string can be parsed as an integer. |
TypesUML
Primitive List<ASSERTION>
| General Info
|
| Name | List<ASSERTION> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Data Type Hash<TRANSLATION_DETAILS, String>
| General Info
|
| Name | Hash<TRANSLATION_DETAILS, String> |
| Visibility | public |
| Abstract | false |
| Leaf | false |
| Root | false |
| Owner | TypesUML |
TypesUML
Data Type List<Any>
TypesUML
Data Type T
|
Dictionary
| |
| A |
| access_control | Package from Package security | |
| ACCESS_GROUP_REF | Class from Package identification | Reference to access group in an access control service. |
| ACTION | Class from Package entry | Used to record a clinical action that has been performed, which may have been ad hoc, or due to the execution of an Activity in an Instruction workflow. Every Action corresponds to a careflow step of some kind or another. |
| ACTIVITY | Class from Package entry | |
| ACTOR | Class from Package demographic | Ancestor of all real-world types, including people and organisations. An actor is any real-world entity capable of taking on a role. |
| ADDRESS | Class from Package demographic | Address of contact, which may be electronic or geographic. |
| ADMIN_ENTRY | Class from Package entry | Entry subtype for administrative information, i.e. information about setting up the clinical process, but not itself clinically relevant. Archetypes will define contained information. |
| AGENT | Class from Package demographic | Generic concept of any kind of agent, including devices, software systems, but not humans or organisations. |
| Aggregate | Class from Package assumed_types | Abstract parent of of the aggregate types List, Set, Array
and Hash. |
| am | Package | |
| am.archetype | Class Diagram | |
| am.archetype.assertion | Class Diagram | |
| am.archetype.constraint_model | Class Diagram | |
| am.archetype.constraint_model. <...> | Class Diagram | |
| am.archetype.ontology | Class Diagram | |
| am.openehr_profile | Class Diagram | |
| am.openehr_profile.data_types. <...> | Class Diagram | |
| am.openehr_profile.data_types. <...> | Class Diagram | |
| am.openehr_profile.data_types. <...> | Class Diagram | |
| am.packages | Class Diagram | |
| am.packages_with_classes | Class Diagram | |
| Any | Class from Package TypesUML | |
| Any | Primitive from Package TypesUML | Abstract supertype. Usually maps to a type like “Any” or “Object” in an object
system. Defined here to provide the value and reference equality semantics. |
| ARCHETYPE | Class from Package archetype | Archetype equivalent to ARCHETYPED class in Common reference model.
Defines semantics of identfication, lifecycle, versioning, composition and specialisation. |
| archetype | Package from Package am | The model of an archetype is straightforward at an abstract level, mimicking the structure of an archetype document as defined in the openEHR Archetype Definition Language
(ADL) document.
An archetype is a modelled as a particular kind of AUTHORED_RESOURCE, and as such, includes descriptive meta-data, language information and revision history.
The ARCHETYPE class adds identifying information, a definition - expressed in terms of constraints on instances of an object model, and an ontology. The archetype definition, the ‘main’ part of an archetype, is an instance of a C_COMPLEX_OBJECT, which is to say, the root of the constraint structure of an archetype always takes the form of a constraint on a non-primitive object type.
The last section of an archetype, the ontology, is represented by its own class, and is what allows the archetypes to be natural language-and terminology-neutral.
A utility class, VALIDITY_KIND is also included in the Archetype package. This class contains one integer attribute and three constant definitions, and is intended to be used as the type of any attribute in this constraint model whose value is logically ‘mandatory’, ‘optional’, or ‘disallowed’. It is used in this model in the classes C_Date, C_Time and C_Date_Time. |
| ARCHETYPE_CONSTRAINT | Class from Package constraint_model | Archetype equivalent to LOCATABLE class in openEHR Common reference model. Defines common constraints for any inheritor of LOCATABLE in any reference model. |
| ARCHETYPE_ID | Class from Package identification | Identifier for archetypes. |
| ARCHETYPE_INTERNAL_REF | Class from Package constraint_model | A constraint defined by proxy, using a reference to an object constraint defined
elsewhere in the same archetype.
Note that since this object refers to another node, there are two objects with available
occurrences values. The local occurrences value on an
ARCHETYPE_INTERNAL_REF should always be used; when setting this from a serialised
form, if no occurrences is mentioned, the target occurrences should be used
(not the standard default of {1..1}); otherwise the locally specified occurrences
should be used as normal. When serialising out, if the occurrences is the same as
that of the target, it can be left out. |
| ARCHETYPE_ONTOLOGY | Class from Package ontology | Local ontology of an archetype. |
| ARCHETYPE_SLOT | Class from Package constraint_model | Constraint describing a `slot' where another archetype can occur. |
| ARCHETYPE_TERM | Class from Package ontology | Representation of any coded entity (term or constraint) in the archetype ontology. |
| ARCHETYPED | Class from Package archetyped | Archetypes act as the configuration basis for the particular structures of instances defined by the reference model. To enable archetypes to be used to create valid data, key classes in the reference model act as “root” points for archetyping; accordingly, these classes have the archetype_details attribute set. An instance of the class ARCHETYPED contains the relevant archetype identification information, allowing generating archetypes to be matched up with data instances |
| archetyped | Package from Package common | |
| Array | Class from Package assumed_types | Container whose storage is assumed to be contiguous |
| Array<Octet> | Primitive from Package TypesUML | |
| ASSERTION | Class from Package assertion | Structural model of a typed first order predicate logic assertion, in the form of an expression tree, including optional variable definitions. |
| assertion | Package from Package archetype | Assertions are expressed in archetypes in typed first-order predicate logic (FOL). They are used in two places: to express archetype slot constraints, and to express invariants in complex object constraints. In both of these places, their role is to constrain something inside the archetype. Constraints on external resources such as terminologies are expressed in the constraint binding part of the archetype ontology, described in the Ontology Package
The concrete syntax of assertion statements in archetypes is designed to be compatible with the OMG Object Constraint Language (OCL). Archetype assertions are essentially statements that contain the following elements:
• variables, which are attribute names, or ADL paths terminating in attribute names (i.e. equivalent of referencing class feature in a programming language);
• manifest constants of any primitive type, plus date/time types
• arithmetic operators: +, *, -, /, ^ (exponent)
• relational operators: >, <, >=, <=, =, !=, matches
• Boolean operators: not, and, or, xor
• quantifiers applied to container variables: for_all, exists
The package described here is currently designed to allow the representation of a general-purpose binary expression tree, as would be generated by a parser. This may be replaced in the future by a more specific model, if needed. |
| ASSERTION_VARIABLE | Class from Package assertion | Definition of a named variable used in an assertion expression. Note: the definition of named variables may change; still under development in ADL2. |
| assumed_library_types | Class Diagram | |
| assumed_types | Class Diagram | |
| assumed_types | Package | This package provides models for common generic and container types not directly supported in UML. |
| assumed_types_date_time | Class Diagram | |
| assumed_types_date_time_summar <...> | Class Diagram | |
| assumed_types_primitive_detail <...> | Class Diagram | |
| assumed_types_primitive_outlin <...> | Class Diagram | |
| ATTESTATION | Class from Package generic | Record an attestation of a party (the committer) to item(s) of record content. The type of attestation is |
| AUDIT_DETAILS | Class from Package generic | The set of attributes required to document the committal of an information item to
a repository. |
| AUTHORED_RESOURCE | Class from Package resource | Abstract idea of an online resource created by a human author. |
| |
| |
| B |
| basic | Package from Package data_types | |
| basic | Package from Package data_types | |
| BASIC_DEFINITIONS | Class from Package definition | Defines globally-used constant values. |
| BINARY_QUERY_NODE | Class from Package sm | |
| Boolean | Primitive from Package TypesUML | Boolean type used for two-valued mathematical logic. |
| |
| |
| C |
| C_ATTRIBUTE | Class from Package constraint_model | Abstract model of constraint on any kind of attribute node. |
| C_BOOLEAN | Class from Package primitive | Constraint on instances of Boolean .
Both attributes cannot be set to False, since this would mean that the Boolean value being constrained cannot be True or False. |
| C_CODE_PHRASE | Class from Package text | Express constraints on instances of CODE_PHRASE. The terminology_id attribute
may be specified on its own to indicate any term from a specified terminology;
the code_list attribute may be used to limit the codes to a specific list. |
| C_COMPLEX_OBJECT | Class from Package constraint_model | Constraint on complex objects, i.e. any object that consists of other object constraints. |
| C_DATE | Class from Package primitive | ISO 8601-compatible constraint on instances of Date in the form either of a set of validity values, or an actual date range. There is no validity flag for ‘year’, since it must always be by definition mandatory in order to have a sensible date at all.
Syntax expressions of instances of this class include “YYYY-??-??” (date with optional month and day). |
| C_DATE_TIME | Class from Package primitive | ISO 8601-compatible constraint on instances of Date_Time. There is no validity flag for ‘year’, since it must always be by definition mandatory in order to have a sensible date/time at all. Syntax expressions of instances of this class include “YYYY-MM-DDT??:??:??” (date/time ith optional time) and “YYYY-MMDDTHH: MM:xx” (date/time, seconds not allowed). |
| C_DEFINED_OBJECT | Class from Package constraint_model | Abstract parent type of C_OBJECT subtypes that are defined by value, i.e. whosedefinitions are actually in the archetype rather than being by reference. |
| C_DOMAIN_TYPE | Class from Package constraint_model | Abstract parent type of domain-specific constrainer types, to be defined in external packages. |
| C_DURATION | Class from Package primitive | ISO 8601-compatible constraint on instances of Duration. In ISO 8601 terms, constraints might are of the form “PWD” (weeks and/or days), “PDTHMS” (days, hours, minutes, seconds) and so on. In official ISO 8601:2004, the ‘W’ (week) designator cannot be mixed in; allowing it is an openEHR-wide exception. |
| C_DV_ORDINAL | Class from Package quantity | Class specifying constraints on instances of DV_ORDINAL. Custom constrainer type for instances of DV_ORDINAL. |
| C_DV_QUANTITY | Class from Package quantity | Constrain instances of DV_QUANTITY. |
| C_DV_STATE | Class from Package basic | Constrainer type for DV_STATE instances. The attribute c_value defines a state/event table which constrains the allowed values of the attribute value in a DV_STATE instance, as well as the order of transitions between values. |
| C_INTEGER | Class from Package primitive | Constraint on instances of Integer . |
| C_MULTIPLE_ATTRIBUTE | Class from Package constraint_model | Abstract model of constraint on any kind of attribute node. |
| C_OBJECT | Class from Package constraint_model | Abstract model of constraint on any kind of object node. |
| C_PRIMITIVE | Class from Package primitive | |
| C_PRIMITIVE_OBJECT | Class from Package constraint_model | Constraint on a primitive type. |
| C_QUANTITY_ITEM | Class from Package quantity | Constrain instances of DV_QUANTITY. |
| C_REAL | Class from Package primitive | Constraint on instances of Real . |
| C_REFERENCE_OBJECT | Class from Package constraint_model | Abstract parent type of C_OBJECT subtypes that are defined by reference. |
| C_SINGLE_ATTRIBUTE | Class from Package constraint_model | Concrete model of constraint on a single-valued attribute node. The meaning of the inherited children attribute is that they are alternatives. |
| C_STRING | Class from Package primitive | Constraint on instances of STRING . |
| C_TIME | Class from Package primitive | ISO 8601-compatible constraint on instances of Time. There is no validity flag for ‘hour’, since it must always be by definition mandatory in order to have a sensible time at all. Syntax xpressions of instances of this class include “HH:??:xx” (time with optional minutes and seconds not allowed). |
| CAPABILITY | Class from Package demographic | Capability of a role, such as “ehr modifier”, “health care provider”. Capability should be backed up by credentials. |
| CARDINALITY | Class from Package constraint_model | Expresses constraints on the cardinality of container objects which are the values of multiply-valued attributes, including uniqueness and ordering, providing the means to state that a container acts like a logical list, set or bag. The cardinality cannot contradict the cardinality of the corresponding attribute within the relevant reference model. |
| CARE_ENTRY | Class from Package entry | The abstract parent of all clinical ENTRY subtypes. A CARE_ENTRY defines protocol and guideline attributes for all clinical Entry subtypes. |
| change_control | Package from Package common | In various openEHR reference models, the semantics of formal change control are required. There are two architectural aspects of managing changes to data.
The first is the concept of a complex information object, being versioned in time, meaning that its creation and all subsequent modifications cause new “versions” to be created, rather than literally overwriting the existing data. Each version includes an audit trail, typically containing the dentity of a user, the date/time of the change, and a reason for the change.
The second aspect recognises that repositories are made up of complex information objects, and that changes are not in fact just made to individual objects, but to the respository itself. Any change by a user may change more than one versioned object in the repository, and the set of such changes - a “change-set” - constitutes the logical unit of change to the repository, taking it from one valid state to the next. |
| Character | Primitive from Package TypesUML | |
| CLUSTER | Class from Package representation | The grouping variant of ITEM, which may contain further instances of ITEM, in an ordered list. |
| CODE_PHRASE | Class from Package text | A fully coordinated (i.e. all “coordination” has been performed) term from a terminology service (as distinct from a particular terminology). |
| CODE_SET_ACCESS | Class from Package terminology | Defines an object providing proxy access to a code_set. |
| common | Package from Package rm | |
| COMPOSITION | Class from Package composition | One version in a VERSIONED_COMPOSITION. A composition is considered the unit of modification of the record, the unit of transmission in record extracts, and the unit of attestation by authorising clinicians. In this latter sense, it may be considered equivalent to a signed document. |
| composition | Package from Package rm | The Composition is the primary ‘data container’ in the openEHR EHR and is the root point of clinical content. Instances of the Composition class can be considered as self-standing data aggregations, or documents in a document-oriented system (similar to HL7 CDA Documents). The key information in a COMPOSITION is found in its content, context, and composer attributes. The majority of the use of paths in openEHR is likely to be within Compositions. |
| constraint_model | Package from Package archetype | The following statements summarise the main features of this package.
Any archetype definition is an instance of a C_COMPLEX_OBJECT, which can be thought of as expressing constraints on a object that is of some particular type (recorded in the attribute rm_type_name ) in a reference model, and which is larger than a simple instance of a primitive type such as String or Integer.
A C_COMPLEX_OBJECT consists of attributes of type C_ATTRIBUTE, which are constraints on the attributes (i.e. any property, including relationships) of the reference model type. Accordingly, each C_ATTRIBUTE records the name of the constrained attribute (in rm_attr_name), the existence and cardinality expressed by the constraint (depending on whether the attribute it constrains is a multiple or single relationship), and the constraint on the object to which this C_ATTRIBUTE refers via its children attribute (according to its reference model) in the form of further C_OBJECTs.
The key subtypes of C_OBJECT, are C_COMPLEX_OBJECT (described above) C_PRIMITIVE_OBJECT (constraints on instances of primitive types such as String, Integer, Boolean and Date).
The other subtypes of C_OBJECT, namely, ARCHETYPE_SLOT, ARCHETYPE_INTERNAL_REF and CONSTRAINT_REF are used to express, respectively, a `slot' where further archetypes can be used to continue describing constraints; a reference to a part of the current archetype that expresses exactly the same constraints needed at another point; and a reference to a constraint on a constraint defined in the archetype ontology, which in turn points to an external knowledge resource, such as a terminology.
All nodes in an archetype constraint structure are instances of the supertype ARCHETYPE_CONSTRAINT, which provides a number of important common features to all nodes.
|
| CONSTRAINT_REF | Class from Package constraint_model | Reference to a constraint described in the same archetype, but outside the main constraint structure. This is used to refer to constraints expressed in terms of external resources, such as constraints on terminology value sets. |
| CONTACT | Class from Package demographic | Description of a means of contact of a party. Actual structure is archetyped. |
| content | Package from Package composition | |
| CONTENT_ITEM | Class from Package content | Abstract ancestor of all concrete content types. |
| CONTRIBUTION | Class from Package change_control | Documents a contribution of one or more versions added to a change-controlled repository. |
| |
| |
| D |
| DATA_STRUCTURE | Class from Package data_structures | |
| data_structures | Package from Package rm | |
| data_types | Package from Package rm | |
| data_types | Package from Package openehr_profile | This data type specification constitutes the lowest level of technical specification of openEHR, and describes a set of types suitable for use in clinical and related information structures. In order for such types to exist, a set of primitive types is assumed, namely Integer, Real, Boolean, Character, String, List, Set, and Array. These have standard definitions in the OMG object model used in UML, OCL, and are available in almost all type systems. The exact assumptions are described in the openEHR Support Reference Model. A number of symbolic definitions (similar to constants in programming) are also described in the Support RM.
The data types described here are named with the class prefix “DV_”, and inherit from the class DATA_VALUE. They have two distinct uses in reference models. Firstly, they may be used as “data values” in reference model structures wherever the DATA_VALUE class appears, for example, in the EHR Reference Model via the ELEMENT.value attribute. Additionally, specific subtypes of the data types described here can also be used as attribute types in other classes in reference models, such as date/times, coded terms and so on. The difference is that in the former case, only subtypes of DATA_VALUE may be used, whilst in the latter case, other types may be used as well, from the assumed set of basic types. |
| DATA_VALUE | Class from Package basic | Serves as a common ancestor of all data value types in openEHR models. |
| Date | DataType from Package TypesUML | |
| Date_Time | DataType from Package TypesUML | |
| date_time | Package from Package quantity | The data_types.quantity.date_time package includes three absolute date/time concepts:
DV_DATE, DV_TIME, DV_DATE_TIME, a relative concept: DV_DURATION, and the concept of partial dates and times, via DV_PARTIAL_DATE, DV_PARTIAL_TIME. |
| definition | Package from Package support | The definition package describes symbolic definitions used by the openEHR models. |
| demographic | Package from Package rm | This document describes the architecture of the openEHR Demographic Information Model. The
semantics are drawn from previous work in GEHR, existing models in CEN 13606 and the HL7v3
RIM, and other work done in Australia.
The intended audience includes:
• Standards bodies producing health informatics standards;
• Software development groups using openEHR;
• Academic groups using openEHR;
• The open source healthcare community;
• Medical informaticians and clinicians intersted in health information;
• Health data managers. |
| directory | Package from Package common | The directory package provides a simple abstraction of a versioned folder structure. The VERSIONED_FOLDER class is the binding of VERSIONED_OBJECT to FOLDER, i.e. it is a VERSIONED_OBJECT.
This means that each of its versions is a FOLDER structure. It provides a means of versioning FOLDER structures over time, which is useful in the EHR, Demographics service or anywhere else where Folders are used to group things. |
| Double | Primitive from Package TypesUML | |
| Duration | DataType from Package TypesUML | |
| DV_ABSOLUTE_QUANTITY | Class from Package quantity | Abstract class defining the concept of quantified entities whose values are absolute with respect to an origin. Dates and Times are the main example. |
| DV_AMOUNT | Class from Package quantity | Abstract class defining the concept of relative quantified ‘amounts’. For relative quantities, the ‘+’ and ‘-’ operators are defined (unlike descendants of DV_ABSOLUTE_QUANTITY, such as the date/time types). |
| DV_BOOLEAN | Class from Package basic | Items which are truly boolean data, such as true/false or yes/no answers. |
| DV_CODED_TEXT | Class from Package text | A text item whose value must be the rubric from a controlled terminology, the key (i.e. the ‘code’) of which is the defining_code attribute. In other words: a DV_CODED_TEXT is a combination of a CODE_PHRASE (effectively a code) and the rubric of that term, from a terminology service, in the language in which the data was authored. |
| DV_COUNT | Class from Package quantity | Countable quantities. |
| DV_DATE | Class from Package date_time | Represents an absolute point in time, as measured on the Gregorian calendar, and
specified only to the day. Semantics defined by ISO 8601. |
| DV_DATE_TIME | Class from Package date_time | Represents an absolute point in time, specified to the second. Semantics defined
by ISO 8601. |
| DV_DURATION | Class from Package date_time |
Represents a period of time with respect to a notional point in
time, which is not
specified. A sign may be used to indicate the duration is
“backwards” in time
rather than forwards.
Note that a deviation from ISO8601 is
supported, allowing the ‘W’ designator to
be mixed with other designators. See
assumed types section in the Support IM.
|
| DV_EHR_URI | Class from Package uri | A DV_EHR_URI is a DV_URI which has the scheme name “ehr”, and which can
only reference elements in EHRs |
| DV_ENCAPSULATED | Class from Package encapsulated | Abstract class defining the common meta-data of all types of encapsulated data. |
| DV_GENERAL_TIME_SPECIFICATION | Class from Package time_specification | |
| DV_IDENTIFIER | Class from Package basic | Type for representing identifiers of real-world entities. Typical identifiers include drivers licence number, social security number, vertans affairs number, prescription id, order id, and so on. |
| DV_INTERVAL | Class from Package date_time | Generic class defining an interval (i.e. range) of a comparable type. An interval is a contiguous subrange of a comparable base type. |
| DV_INTERVAL<DV_DATE_TIME> | Class from Package quantity | |
| DV_INTERVAL<DV_DATE> | DataType from Package TypesUML | |
| DV_MULTIMEDIA | Class from Package encapsulated | A specialisation of DV_ENCAPSULATED for audiovisual and biosignal types.
Includes further metadata relating to multimedia types which are not applicable t other subtypes of DV_ENCAPSULATED. |
| DV_ORDERED | Class from Package quantity | Abstract class defining the concept of ordered values, which includes ordinals as well as true quantities. It defines the functions ‘<’ and is_strictly_comparable_to, the latter of which must evaluate to True for instances being compared with the ‘<’ function, or used as limits in the DV_INTERVAL class. |
| DV_ORDINAL | Class from Package quantity | Models rankings and scores, e.g. pain, Apgar values, etc, where there is a)
implied ordering, b) no implication that the distance between each value is constant,
and c) the total number of values is finite.
Note that although the term ‘ordinal’ in mathematics means natural numbers only, here any integer is allowed, since negative and zero values are often used by medical professionals
for values around a neutral point. Examples of sets of ordinal values:
-3, -2, -1, 0, 1, 2, 3 -- reflex response values
0, 1, 2 -- Apgar values
Used for recording any clinical datum which is customarily recorded using symbolic
values. Example: the results on a urinalysis strip, e.g. {neg, trace, +,
++, +++} are used for leucocytes, protein, nitrites etc; for non-haemolysed
blood {neg, trace, moderate}; for haemolysed blood {neg, trace,
small, moderate, large}. |
| DV_PARAGRAPH | Class from Package text | A logical composite text value consisting of a series of DV_TEXTs, i.e. plain text (optionally coded) potentially with simple formatting, to form a larger tract of prose, which may be interpreted for display purposes as a paragraph. |
| DV_PARSABLE | Class from Package encapsulated | Encapsulated data expressed as a parsable String. The internal model of the data item is not described in the openEHR model in common with other encapsulated types, but in this case, the form of the data is assumed to be plaintext, rather than compressed or other types of large binary data. |
| DV_PERIODIC_TIME_SPECIFICATION | Class from Package time_specification | |
| DV_PROPORTION | Class from Package quantity | Models a ratio of values, i.e. where the numerator and denominator are both pure numbers. |
| DV_QUANTIFIED | Class from Package quantity | Abstract class defining the concept of true quantified values, i.e. values which are
not only ordered, but which have a precise magnitude. |
| DV_QUANTITY | Class from Package quantity | Quantitified type representing “scientific” quantities, i.e. quantities expressed as a
magnitude and units.
Units were inspired by the Unified Code for Units of Measure (UCUM), developed
by Gunther Schadow and Clement J. McDonald of The Regenstrief Institute
Can also be used for time durations, where it is more convenient to treat these as
simply a number of seconds rather than days, months, years. |
| DV_STATE | Class from Package basic | For representing state values which obey a defined state machine, such as a variable representing the states of an instruction or care process. |
| DV_TEMPORAL | Class from Package date_time | Specialised temporal variant of DV_ABSOLUTE_QUANTITY whose diff type is
DV_DURATION. |
| DV_TEXT | Class from Package text | A plain text item, which may contain any amount of legal characters arranged as e.g. words, sentences etc (i.e. one DV_TEXT may be more than one word). Any DV_TEXT may be “coded” by adding mappings to it. |
| DV_TIME | Class from Package date_time | Represents an absolute point in time from an origin usually interpreted as meaning
the start of the current day, specified to the second. Semantics defined by ISO 8601. |
| DV_TIME_SPECIFICATION | Class from Package time_specification | |
| DV_URI | Class from Package uri | A reference to an object which conforms to the Universal Resource Identifier (URI) standard, as defined by W3C RFC 2936. See "Universal Resource Identifiers in WWW" by Tim Berners-Lee at http://www.ietf.org/rfc/rfc2396.txt.
This is a World-Wide Web RFC for global identification of resources.
See http://www.w3.org/Addressing for a starting point on URIs.
See http://www.ietf.org/rfc/rfc2806.txt for new URI types like telephone, fax and modem numbers. |
| |
| |
| E |
| EHR | Class from Package ehr | The EHR object is the root object and access point of an EHR for a subject of care. |
| ehr | Package from Package rm | |
| EHR_ACCESS | Class from Package ehr | EHR-wide access contol object. All access decisions to data in the EHR must be made in accordance with the policies and rules in this object. |
| EHR_STATUS | Class from Package ehr | Single object per EHR giving various EHR-wide information. |
| ELEMENT | Class from Package representation | The leaf variant of ITEM, to which a DATA_VALUE instance is attached. |
| encapsulated | Package from Package data_types | The data_types.encapsulated package contains classes representing data values whose internal structure is defined outside the EHR model, such as multimedia and parsable data. |
| ENTRY | Class from Package entry | The abstract parent of all ENTRY subtypes. An ENTRY is the root of a logical item of “hard” clinical information created in the “clinical statement” context, within a clinical session. There can be numerous such contexts in a clinical session. Observations and other Entry types only ever document information captured/created in the event documented by the enclosing Composition.
An ENTRY is also the minimal unit of information any query should return, since a whole ENTRY (including subparts) records spatial structure, timing information, and contextual information, as well as the subject and generator of the information. |
| entry | Package from Package content | All information which is created in the openEHR health record is expressed as an instance of a class in the entry package, containing the ENTRY class and a number of descendants. An ENTRY instance is logically a single ‘clinical statement’, and may be a single short narrative phrase, but may also contain a significant amount of data, e.g. an entire microbiology result, a psychiatric examination, a complex prescription. In terms of actual content, the Entry classes are the most important in the openEHR EHR Information Model, since they define the semantics of all the ‘hard’ information in the record. They are intended to be achetyped, and in fact, archetypes for Entries make up the vast majority of important clinical archetypes defined. |
| EVALUATION | Class from Package entry | Entry type for evaluation statements. |
| EVENT | Class from Package history | Defines the abstract notion of a single event in a series. This class is generic, allowing types to be generated which are locked to particular spatial types, such as EVENT. Subtypes express point or intveral data. |
| EVENT_CONTEXT | Class from Package composition | Documents the context information of a healthcare event involving the subject of care and the health system. The context information recorded here are independent of the attributes recorded in the version audit, which document the “system interaction” context, i.e. the context of a user interacting with the health record system. Healthcare events include patient contacts, and any other business activity, such as pathology investigations which take place on behalf of the patient. |
| EXPR_BINARY_OPERATOR | Class from Package assertion | Binary operator expression node. |
| EXPR_ITEM | Class from Package assertion | Abstract parent of all expression tree items. |
| EXPR_LEAF | Class from Package assertion | Expression tree leaf item |
| EXPR_OPERATOR | Class from Package assertion | Abstract parent of operator types. |
| EXPR_UNARY_OPERATOR | Class from Package assertion | Unary operator expression node. |
| EXTERNAL_ENVIRONMENT_ACCESS | Class from Package support | A mixin class providing access to services in the external environment. |
| |
| |
| F |
| FEEDER_AUDIT | Class from Package archetyped | |
| FEEDER_AUDIT_DETAILS | Class from Package archetyped | Audit details for any system in a feeder system chain. Audit details here means the general notion of who/where/when the information item to which the audit is attached was created. None of the attributes is defined as mandatory, however, in different scenarios, various combinations of attributes will usually be mandatory. This can be controlled by specifying feeder audit details in legacy archetypes. |
| FOLDER | Class from Package directory | The concept of a named folder. |
| |
| |
| G |
| generic | Package from Package common | |
| GENERIC_ENTRY | Class from Package integration | |
| GENERIC_ID | Class from Package identification | Generic identifier type for identifiers whose format is othterwise unknown to openEHR. Includes an attribute for naming the identification scheme (which may well be local). |
| GROUP | Class from Package demographic | A group is a real world group of parties which is created by another party, usually an organisation, for some specific purpose. A typical clinical example is that of the specialist care team, e.g. “cardiology team”. The members of the group usually work together. |
| |
| |
| H |
| Hash | Class from Package assumed_types | Type representing a keyed table of values. T is the value type, and U the type of
the keys. |
| Hash<String,String> | DataType from Package TypesUML | |
| Hash<TRANSLATION_DETAILS, Stri <...> | DataType from Package TypesUML | |
| HIER_OBJECT_ID | Class from Package identification | Hierarchical identifiers consisting of a root part and an optional extension. |
| HISTORY | Class from Package history | Root object of a linear history, i.e. time series structure.. |
| history | Package from Package data_structures | The history package defines classes which formalise the concept of past, linear time, via which historical data of any structural complexity can be recorded. It supports both instantaneous and interval event samples within periodic and aperiodic series. Data recorded in interval events are tagged with a mathematical function, including ‘point-in-time’, ‘mean’, ‘delta’ and so on, as defined by the openEHR “event math function” vocabulary.
It also supports the inclusion of “summary” data, i.e. a textual or image item which summarises in some way the entire history. |
| |
| |
| I |
| identification | Package from Package support | The identification package describes a model of references and identifiers for information entities only. Real-world entity identifiers are defined in the openEHR Data Types information model. |
| IMPORTED_VERSION | Class from Package change_control | Versionable objects that have been copied from another location and imported into a local version container. |
| INSTRUCTION | Class from Package entry | Used to specify actions in the future. Enables simple and complex specifications
to be expressed, including in a fully-computable workflow form. |
| INSTRUCTION_DETAILS | Class from Package entry | Used to record details of the Instruction causing an Action. |
| Integer | Primitive from Package TypesUML | |
| integration | Package from Package rm | |
| INTERNET_ID | Class from Package identification | Model of a reverse internet domain, as used to uniquely identify an internet domain. In the form of a dot-separated string in the reverse order of a domain name, specified by IETF RFC 1034
(http://www.ietf.org/rfc/rfc1034.txt). |
| Interval | Class from Package assumed_types | |
| INTERVAL_EVENT | Class from Package history | Defines a single interval event in a series. |
| Interval<Date_Time> | DataType from Package TypesUML | |
| Interval<Date> | DataType from Package TypesUML | |
| Interval<Duration> | DataType from Package TypesUML | |
| Interval<Integer> | DataType from Package TypesUML | |
| Interval<Real> | DataType from Package TypesUML | |
| Interval<T> | Primitive from Package TypesUML | |
| Interval<Time> | DataType from Package TypesUML | |
| ISM_TRANSITION | Class from Package entry | Model of a transition in the Instruction State machine, caused by a careflow step.
The attributes document the careflow step as well as the ISM transition. |
| ISO_OID | Class from Package identification | Model of ISO’s Object Identifier (oid) as defined by the standard ISO/IEC 8824 .
Oids are formed from integers separated by dots. Each non-leaf node in an Oid starting from the left corresponds to an assigning authority, and identifies that authority’s namespace, inside which the remaining part of the identifier is locally unique. |
| ISO8601_DATE | Class from Package assumed_types | Represents an absolute point in time, as measured on the Gregorian calendar, and specified only to the day. |
| ISO8601_DATE_TIME | Class from Package assumed_types | |
| ISO8601_DURATION | Class from Package assumed_types | |
| ISO8601_TIME | Class from Package assumed_types | Represents an absolute point in time from an origin usually interpreted as meaning the start of the current day, specified to the second. |
| ISO8601_TIMEZONE | Class from Package assumed_types | |
| ITEM | Class from Package representation | The abstract parent of CLUSTER and ELEMENT representation classes. |
| ITEM_LIST | Class from Package item_structure | Logical list data structure, where each item has a value and can be referred to by a name and a positional index in the list. The list may be empty. |
| ITEM_SINGLE | Class from Package item_structure | Logical single value data structure. |
| ITEM_STRUCTURE | Class from Package item_structure | Abstract parent class of all spatial data types. |
| item_structure | Package from Package data_structures | |
| ITEM_TABLE | Class from Package item_structure | Logical relational database style table data structure, in which columns are named and ordered with respect to each other.
Implemented using Cluster-per-row encoding. Each row Cluster must have an identical number of Elements, each of which in turn must have identical names and value types in the corresponding postions in each row.
Some columns may be designated ‘key’ columns, containing key data for each row, in the manner of relational tables. This allows row-naming, where each row represents a body site, a blood antigen etc. All values in a column have the same data type. |
| ITEM_TREE | Class from Package item_structure | Logical tree data structure. The tree may be empty. |
| |
| |
| L |
| LINK | Class from Package archetyped | The LINK type defines a logical relationship between two items, such as two ENTRYs or an ENTRY and a COMPOSITION. Links can be used across compositions, and across EHRs. Links can potentially be used between interior (i.e. non-archetype root) nodes, although this probably should be prevented in archetypes. Multiple LINKs can be attached to the root object of any archetyped structure to give the effect of a 1->N link |
| List | Class from Package assumed_types | Ordered container that may contain duplicates. |
| List<Any> | DataType from Package TypesUML | |
| List<ASSERTION> | Primitive from Package TypesUML | |
| List<C_OBJECT> | DataType from Package TypesUML | |
| List<CLUSTER> | Primitive from Package TypesUML | |
| List<DV_IDENTIFIER> | Primitive from Package TypesUML | |
| List<DV_TEXT> | DataType from Package TypesUML | |
| List<ELEMENT> | DataType from Package TypesUML | |
| List<OBJECT_REF> | Primitive from Package TypesUML | |
| List<OBJECT_VERSION_ID> | Primitive from Package TypesUML | |
| List<PARTICIPATION> | DataType from Package TypesUML | |
| List<REFERENCE_RANGE> | Primitive from Package TypesUML | |
| List<String> | DataType from Package TypesUML | |
| List<VERSION> | DataType from Package TypesUML | |
| LOCATABLE | Class from Package archetyped | Root class of all information model classes that can be archetyped. |
| LOCATABLE_REF | Class from Package identification | Reference to a LOCATABLE instance inside the top-level content structure inside a VERSION; the path attribute is applied to the object that VERSION.data points to. |
| |
| |
| M |
| measurement | Package from Package support | |
| MEASUREMENT_SERVICE | Class from Package measurement | Defines an object providing proxy access to a measurement information service. |
| MERGED_VERSION | Class from Package change_control | Merged Versions, recording the list of input versions to the merge in addition to standard Version attributes. |
| |
| |
| N |
| navigation | Package from Package content | |
| NON_TERMINAL_STATE | Class from Package basic | Definition of a non-terminal state in a state machine, i.e. one that has transitions. |
| Numeric | Primitive from Package TypesUML | Abstract notional parent class of numeric types, which are types which have various
arithmetic and comparison operators defined. |
| |
| |
| O |
| OBJECT_ID | Class from Package identification | Ancestor class of identifiers of informational objects. Ids may be completely meaningless, in which case their only job is to refer to something, or may carry some information to do with the identified object. |
| OBJECT_REF | Class from Package identification | Class describing a reference to another object, which may exist locally or be maintained outside the current namespace, e.g. in another service. Services are usually external, e.g. available in a LAN (including on the same host) or the internet via Corba, SOAP, or some other distributed protocol. However, in small systems they may be part of the same executable as the data containing the Id. |
| OBJECT_VERSION_ID | Class from Package identification | Globally unique identifier for one version of a versioned object. |
| OBSERVATION | Class from Package entry | Entry subtype for all clinical data in the past or present, i.e. which (by the time it is recorded) has already occurred. OBSERVATION data is expressed using the class HISTORY, which guarantees that it is situated in time. |
| Octet | Primitive from Package TypesUML | |
| ontology | Package from Package archetype | All linguistic and terminological entities in an archetype are represented in the ontology part of an archetype, whose semantics are given in the Ontology package. |
| OPENEHR_DEFINITIONS | Class from Package definition | Inheritance class to provide access to constants defined in other packages. |
| openehr_profile | Package from Package am | |
| OPENEHR_TERMINOLOGY_CODE_SET_I <...> | Class from Package terminology | List of identifiers for code sets in the openEHR terminology. |
| OPENEHR_TERMINOLOGY_GROUP_IDEN <...> | Class from Package terminology | List of identifiers for groups in the openEHR terminology. |
| OPERATOR_KIND | Class from Package assertion | Enumeration type for operator types in assertion expressions |
| Ordered | Primitive from Package TypesUML | Abstract notional parent class of ordered, types i.e. types on which the ‘<‘ operator
is defined. |
| Ordered_Numeric | Primitive from Package TypesUML | Abstract notional parent class of ordered, numeric types, which are types with ‘<‘
and arithmetic operators defined |
| ORGANISATION | Class from Package demographic | Generic description of organisations. An organisation is a legally constituted body whose existence (in general) outlives the existence of parties considered to be part of it. |
| ORIGINAL_VERSION | Class from Package change_control | |
| overall.packages | Class Diagram | |
| |
| |
| P |
| PARTICIPATION | Class from Package generic | Model of a participation of a Party (any Actor or Role) in an activity. |
| PARTY | Class from Package demographic | Ancestor of all party types, including real world entities and their roles. A party is any entity which can participate in an activity. The name attribute inherited from LOCATABLE is used to indicate the actual type of party (note that the actual names, i.e. identities of parties are indicated in the identities attribute, not the name attribute). |
| PARTY_IDENTIFIED | Class from Package generic | |
| PARTY_IDENTITY | Class from Package demographic | An identity “owned” by a PARTY, such as a person name or company name, and
which is used by the party to identify itself. Actual structure is archetyped. |
| PARTY_PROXY | Class from Package generic | Abstract concept of a proxy description of a party, including an optional link to
data for this party in a demographic or other identity management system.
Subtyped into PARTY_IDENTIFIED and PARTY_SELF. |
| PARTY_REF | Class from Package identification | Identifier for parties in a demographic or identity service. There are typically a number of subtypes of the PARTY class, including PERSON, ORGANISATION, etc. |
| PARTY_RELATED | Class from Package generic | Relationship of subject of this ENTRY to the subject of the record. May be coded. If it is the atient, coded as “self”. |
| PARTY_RELATIONSHIP | Class from Package demographic | Generic description of a relationship between parties. |
| PARTY_SELF | Class from Package generic | Party proxy representing the subject of the record. |
| PATHABLE | Class from Package archetyped | Abstract parent of all classes whose instances are reachable by paths, and which know how to locate child object by paths. The parent feature may be implemented as a function or attribute. |
| PERSON | Class from Package demographic | Generic description of persons. Provides a dedicated type to which Person archetypes can be targeted. |
| POINT_EVENT | Class from Package history | Defines a single point event in a series. |
| primitive | Package from Package constraint_model | Ultimately any archetype definition will devolve down to leaf node constraints on instances of primitive types. The primitives package defines the semantics of constraint on such types. Most of the types provide at least two alternative ways to represent the constraint; for example the C_DATE type allows the constraint to be expressed in the form of a pattern (defined in the ADL specification) or an Interval. Note that the interval form of dates is probably only useful for historical date checking (e.g. the date of an antique or a particular batch of vaccine), rather than constraints on future date/times. |
| PROPORTION_KIND | Class from Package quantity | Class of enumeration constants defining types of proportion for the DV_PROPORTION class. |
| |
| |
| Q |
| quantity | Package from Package data_types | |
| quantity | Package from Package data_types | |
| QUERY | Class from Package sm | |
| QUERY_ITEM | Class from Package sm | |
| QUERY_LEAF | Class from Package sm | |
| QUERY_NODE | Class from Package sm | |
| |
| |
| R |
| Real | Primitive from Package TypesUML | Type used to represent decimal numbers. Typically corresponds to a single-precision
floating point value in most languages. |
| REFERENCE_RANGE | Class from Package quantity | Defines a named range to be associated with any ORDERED datum. Each such range is particular to the patient and context, e.g. sex, age, and any other factor which affects ranges. |
| representation | Package from Package data_structures | |
| resource | Package from Package common | The common.resource package defines the structure and semantics of the general notion of an online resource which has been created by a human author, and consequently for which natural language is a factor. |
| RESOURCE_DESCRIPTION | Class from Package resource | Defines the descriptive meta-data of a resource. |
| RESOURCE_DESCRIPTION_ITEM | Class from Package resource | Language-specific detail of resource description. When a resource is translated for use in another language environment, each RESOURCE_DESCRIPTION_ITEM needs to be copied and translated into the new language. |
| REVISION_HISTORY | Class from Package generic | Defines the notion of a revision history of audit items, each associated with the version for which that audit was committed. |
| REVISION_HISTORY_ITEM | Class from Package generic | An entry in a revision history, corresponding to a version from a versioned container
Consists of AUDIT_DETAILS instances with revision identifier of the revision to which the AUDIT_DETAILS intance belongs. |
| rm | Package | |
| rm.common.archetyped | Class Diagram | |
| rm.common.change_control | Class Diagram | |
| rm.common.directory | Class Diagram | |
| rm.common.generic | Class Diagram | |
| rm.common.packages | Class Diagram | |
| rm.common.resource | Class Diagram | |
| rm.composition | Class Diagram | |
| rm.composition.content | Class Diagram | |
| rm.composition.content.entry | Class Diagram | |
| rm.composition.content.navigat <...> | Class Diagram | |
| rm.data_structures | Class Diagram | |
| rm.data_structures.history | Class Diagram | |
| rm.data_structures.item_struct <...> | Class Diagram | |
| rm.data_structures.representat <...> | Class Diagram | |
| rm.data_types | Class Diagram | |
| rm.data_types.basic | Class Diagram | |
| rm.data_types.encapsulated | Class Diagram | |
| rm.data_types.quantity | Class Diagram | |
| rm.data_types.quantity.date_ti <...> | Class Diagram | |
| rm.data_types.text | Class Diagram | |
| rm.data_types.time_specificati <...> | Class Diagram | |
| rm.data_types.uri | Class Diagram | |
| rm.demographic | Class Diagram | |
| rm.ehr | Class Diagram | |
| rm.entry.observation_reduced | Class Diagram | |
| rm.integration | Class Diagram | |
| rm.packages | Class Diagram | |
| rm.Packages_with_Classes | Class Diagram | |
| rm.security | Class Diagram | |
| rm.support | Class Diagram | |
| rm.support.definition | Class Diagram | |
| rm.support.identification | Class Diagram | |
| rm.support.measurement | Class Diagram | |
| rm.support.terminology | Class Diagram | |
| ROLE | Class from Package demographic | Generic description of a role performed by an actor. The role corresponds to a competency of the party. Roles are used to define the responsibilities undertaken by a party for a purpose. Roles should have credentials qualifying the performer to perform the role. |
| |
| |
| S |
| SECTION | Class from Package navigation | Represents a heading in a heading structure, or “section tree”. |
| security | Package from Package rm | Security Information Model Placeholder
|
| Set | Class from Package assumed_types | Non-ordered conatiner that does not contain duplicates |
| Set<CODE_PHRASE> | DataType from Package TypesUML | |
| Set<DV_EHR_URI> | Primitive from Package TypesUML | |
| Set<Integer> | DataType from Package TypesUML | |
| Set<LOCATABLE_REF> | Primitive from Package TypesUML | |
| Set<OBJECT_VERSION_ID> | Primitive from Package TypesUML | |
| Set<PARTY_REF> | Primitive from Package TypesUML | |
| Set<Real> | DataType from Package TypesUML | |
| Set<String> | DataType from Package TypesUML | |
| sm | Package | |
| sm.EHR_Client_API | Class Diagram | |
| STATE | Class from Package basic | Abstract definition of one state in a state machine. |
| STATE_MACHINE | Class from Package basic | Definition of a state machine in terms of states, transition events and outputs, and
next states. |
| String | Class from Package assumed_types | |
| String | Primitive from Package TypesUML | Strings of characters, as used to represent textual data in any natural or formal language. |
| support | Package from Package rm | |
| |
| |
| T |
| T | DataType from Package TypesUML | |
| template | Package from Package am | |
| TEMPLATE_ID | Class from Package identification | Identifier for templates. Lexical form to be determined. |
| TERM_MAPPING | Class from Package text | Represents a coded term mapped to a DV_TEXT, and the relative match of the target term with respect to the mapped item. Plain or coded text items may appear in the EHR for which one or mappings in alternative terminologies are required. Mappings are only used to enable computer processing, so they can only be instances of DV_CODED_TEXT. |
| TERMINAL_STATE | Class from Package basic | |
| terminology | Package from Package support | This describes the terminology package, which contains classes for accessing the openEHR support terminology from within instances of classes defined in the reference model. |
| TERMINOLOGY_ACCESS | Class from Package terminology | Defines an object providing proxy access to a terminology. |
| TERMINOLOGY_ID | Class from Package identification | Identifier for terminologies such accessed via a terminology query service. In this class, the value attribute identifies the Terminology in the terminology service, e.g. “SNOMED-CT”. A terminology is assumed to be in a particular language, which must be explicitly specified.
The value if the id attribute is the precise terminology id identifier, including actual release (i.e. actual “version”), local modifications etc; e.g. “ICPC2” |
| TERMINOLOGY_SERVICE | Class from Package terminology | Defines an object providing proxy access to a terminology service. |
| text | Package from Package data_types | Represents a coded term mapped to a DV_TEXT, and the relative match of the target term with respect to the mapped item. Plain or coded text items may appear in the EHR for which one or mappings in alternative terminologies are required.
Mappings are only used to enable computer processing, so they can only be instances of DV_CODED_TEXT. |
| text | Package from Package data_types | |
| Time | DataType from Package TypesUML | |
| TIME_DEFINITIONS | Class from Package assumed_types | Definitions for date/time classes. Note that the timezone limits are set by where
the international dateline is. Thus, time in New Zealand is quoted using +12:00,
not -12:00. |
| time_specification | Package from Package data_types | |
| TRANSITION | Class from Package basic | Definition of a state machine transition. |
| TRANSLATION_DETAILS | Class from Package resource | Class providing details of a natural language translation. |
| TypesUML | Package | This package contains the UML representation and semantics of assumed data types.
It overcomes the inability of UML to represent O-O generic types properly. |
| |
| |
| U |
| U | DataType from Package TypesUML | |
| UID | Class from Package identification | Abstract parent of classes representing unique identifiers which identify information entities in a durable way. UIDs only ever identify one IE in time or space andare never re-used. |
| UID_BASED_ID | Class from Package identification | Abstract model of UID-based identifiers consisting of a root part and an optional
extension; lexical form:
root ‘::’ extension |
| UNARY_QUERY_NODE | Class from Package sm | |
| uri | Package from Package data_types | |
| UUID | Class from Package identification | Model of the DCE Universal Unique Identifier or UUID which takes the form of hexadecimal integers separated by hyphens, following the pattern 8-4-4-4-12 as defined by the Open Group, CDE 1.1 Remote Procedure Call specification, Appendix A. Also known as a GUID. |
| |
| |
| V |
| VALIDITY_KIND | Class from Package archetype | An enumeration of three values which may commonly occur in constraint models. |
| VALIDITY_KIND | Enumeration from Package primitive | |
| VERSION | Class from Package change_control | One version within a Version container, containing data, create and commit audit trails, and optional attestations. |
| VERSION_TREE_ID | Class from Package identification | Version tree identifier for one version. |
| VERSIONED_COMPOSITION | Class from Package ehr | Version-controlled composition abstraction, defined by inheriting VERSIONED_OBJECT. |
| VERSIONED_EHR_ACCESS | Class from Package ehr | |
| VERSIONED_EHR_STATUS | Class from Package ehr | Versioning container for EHR_STATUS instance. |
| VERSIONED_FOLDER | Class from Package directory | |
| VERSIONED_OBJECT | Class from Package change_control | Version control abstraction, defining semantics for versioning one complex object. |
| VERSIONED_PARTY | Class from Package demographic | |
| |
|