bmm_version = <"2.4">
rm_publisher = <"openehr">
schema_name = <"base">
rm_release = <"1.0.4">
schema_revision = <"1.0.4.2">
schema_lifecycle_state = <"stable">
schema_description = <"openEHR base types.">
schema_author = <"Thomas Beale <thomas.beale@openehr.org>, code-generator">
packages = <
	["org.openehr.base.base_types"] = <
		name = <"org.openehr.base.base_types">
		packages = <
			["identification"] = <
				name = <"identification">
				classes = <"ARCHETYPE_ID", "GENERIC_ID", "HIER_OBJECT_ID", "LOCATABLE_REF", "OBJECT_ID", "OBJECT_REF", "OBJECT_VERSION_ID", "PARTY_REF", "TERMINOLOGY_ID", "VERSION_TREE_ID", "UID_BASED_ID", "UUID", "INTERNET_ID", "UID", "ISO_OID", "TEMPLATE_ID", "ACCESS_GROUP_REF">
			>
			["definitions"] = <
				name = <"definitions">
				classes = <"OPENEHR_DEFINITIONS", "BASIC_DEFINITIONS", "VALIDITY_KIND", "VERSION_STATUS">
			>
			["terminology"] = <
				name = <"terminology">
				classes = <"Terminology_code", "Terminology_term">
			>
		>
	>
	["org.openehr.base.bmm"] = <
		name = <"org.openehr.base.bmm">
		packages = <
			["rm_access"] = <
				name = <"rm_access">
				classes = <"BMM_MODEL_ACCESS", "BMM_SCHEMA_DESCRIPTOR", "BMM_SCHEMA", "P_BMM_SCHEMA_DESCRIPTOR", "BMM_SCHEMA_METADATA_KEY">
			>
			["core"] = <
				name = <"core">
				classes = <"BMM_TYPE", "BMM_CLASS", "BMM_PROPERTY", "BMM_CONTAINER_TYPE", "BMM_GENERIC_TYPE", "BMM_SIMPLE_TYPE", "BMM_ENUMERATION", "BMM_ENUMERATION_STRING", "BMM_ENUMERATION_INTEGER", "BMM_PACKAGE", "BMM_PARAMETER_TYPE", "BMM_ENTITY", "BMM_CONTAINER_PROPERTY", "BMM_MODEL", "BMM_PACKAGE_CONTAINER", "BMM_GENERIC_CLASS", "BMM_DEFINITIONS", "BMM_MODEL_ELEMENT", "BMM_UNITARY_TYPE", "BMM_INDEXED_CONTAINER_TYPE", "BMM_DEFINED_TYPE", "BMM_SIMPLE_CLASS", "BMM_MODEL_METADATA">
			>
		>
	>
	["org.openehr.base.expression"] = <
		name = <"org.openehr.base.expression">
		packages = <
			["types"] = <
				name = <"types">
				classes = <"EXPR_TYPE_DEF", "TYPE_DEF_BOOLEAN", "TYPE_DEF_DATE", "TYPE_DEF_DATE_TIME", "TYPE_DEF_DURATION", "TYPE_DEF_INTEGER", "TYPE_DEF_OBJECT_REF", "TYPE_DEF_REAL", "TYPE_DEF_STRING", "TYPE_DEF_TERMINOLOGY_CODE", "TYPE_DEF_TIME", "TYPE_DEF_URI">
			>
			["core"] = <
				name = <"core">
				classes = <"ASSERTION", "ASSIGNMENT", "EXPR_BINARY_OPERATOR", "EXPR_FUNCTION_CALL", "EXPRESSION", "EXPR_LEAF", "EXPR_LITERAL", "EXPR_OPERATOR", "EXPR_UNARY_OPERATOR", "EXPR_VARIABLE_REF", "EXTERNAL_QUERY", "EXPR_VALUE", "STATEMENT_SET", "STATEMENT", "VARIABLE_DECLARATION", "OPERATOR_DEF", "EXPR_VALUE_REF", "EXPR_FOR_ALL">
			>
		>
	>
	["org.openehr.base.foundation_types"] = <
		name = <"org.openehr.base.foundation_types">
		classes = <"Any", ...>
		packages = <
			["time"] = <
				name = <"time">
				classes = <"IDate", "IDate_time", "IDuration", "ITimezone", "ITime", "Temporal", "Time_Definitions", "Date", "Date_time", "Time", "Duration", "Timezone">
			>
			["structures"] = <
				name = <"structures">
				classes = <"Hash", "Aggregate", "List", "Set", "Array">
			>
			["primitive_types"] = <
				name = <"primitive_types">
				classes = <"Uri", "Comparable", "Ordered_Numeric", "Integer", "Double", "Numeric", "Octet", "Character", "Boolean", "String", "Real", "Integer64", "Ordered">
			>
			["functional"] = <
				name = <"functional">
				classes = <"TUPLE", "FUNCTION", "TUPLE1", "TUPLE2", "ROUTINE", "PROCEDURE">
			>
			["iso8601_time"] = <
				name = <"iso8601_time">
				classes = <"Iso8601_date_time", "Iso8601_duration", "Iso8601_time", "Iso8601_timezone", "Iso8601_type", "Iso8601_date">
			>
			["interval"] = <
				name = <"interval">
				classes = <"Multiplicity_interval", "Proper_interval", "Interval", "Point_interval", "Cardinality">
			>
		>
	>
	["org.openehr.base.resource"] = <
		name = <"org.openehr.base.resource">
		classes = <"AUTHORED_RESOURCE", "RESOURCE_DESCRIPTION", "TRANSLATION_DETAILS", "RESOURCE_DESCRIPTION_ITEM", "RESOURCE_ANNOTATIONS">
	>
	["org.openehr.base.bmm_persistence"] = <
		name = <"org.openehr.base.bmm_persistence">
		classes = <"P_BMM_CLASS", "P_BMM_ENUMERATION", "P_BMM_SCHEMA", "P_BMM_PROPERTY", "P_BMM_GENERIC_PARAMETER", "P_BMM_TYPE", "P_BMM_CONTAINER_TYPE", "P_BMM_SIMPLE_TYPE", "P_BMM_OPEN_TYPE", "P_BMM_GENERIC_TYPE", "P_BMM_PACKAGE", "P_BMM_PACKAGE_CONTAINER", "P_BMM_CONTAINER_PROPERTY", "P_BMM_SINGLE_PROPERTY", "P_BMM_SINGLE_PROPERTY_OPEN", "P_BMM_GENERIC_PROPERTY", "P_BMM_ENUMERATION_INTEGER", "P_BMM_ENUMERATION_STRING", "BMM_INCLUDE_SPEC", "P_BMM_MODEL_ELEMENT", "P_BMM_BASE_TYPE", "BMM_SCHEMA_STATE">
	>
>
primitive_types = <
	["Terminology_code"] = <
		name = <"Terminology_code">
		documentation = <"Logically primitive type representing a reference to a terminology concept, in the form of a terminology identifier, optional version, and a code or code string from the terminology.">
		ancestors = <"Any", ...>
		properties = <
			["terminology_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"terminology_id">
				documentation = <"The archetype environment namespace identifier used to identify a terminology. Typically a value like \"snomed_ct\" that is mapped elsewhere to the full URI identifying the terminology.">
				is_mandatory = <True>
				type = <"String">
			>
			["terminology_version"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"terminology_version">
				documentation = <"Optional string value representing terminology version, typically a date or dotted numeric.">
				type = <"String">
			>
			["code_string"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"code_string">
				documentation = <"A terminology code or post-coordinated code expression, if supported by the terminology. The code may refer to a single term, a value set consisting of multiple terms, or some other entity representable within the terminology.">
				is_mandatory = <True>
				type = <"String">
			>
			["uri"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"uri">
				documentation = <"The URI reference that may be used as a concrete key into a notional terminology service for queries that can obtain the term text, definition, and other associated elements.">
				type = <"Uri">
			>
		>
	>
	["Terminology_term"] = <
		name = <"Terminology_term">
		documentation = <"Leaf type representing a term from a terminology, which consists of the term text and the code, i.e. a concept reference.">
		ancestors = <"Any", ...>
		properties = <
			["concept"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"concept">
				documentation = <"Refrence to the terminology concept formally representing this term.">
				is_mandatory = <True>
				type = <"Terminology_code">
			>
			["text"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"text">
				documentation = <"Text of term.">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["Any"] = <
		name = <"Any">
		documentation = <"Abstract supertype. Usually maps to a type like Any or Object in an object-oriented technology. Defined here to provide value and reference equality semantics.">
		is_abstract = <True>
		functions = <
			["is_equal"] = <
				name = <"is_equal">
				documentation = <"Value equality.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Any">
					>
				>
			>
			["infix ="] = <
				name = <"infix =">
				documentation = <"Reference equality.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						documentation = <"Reference equality.">
						type = <"Any">
					>
				>
			>
			["instance_of"] = <
				name = <"instance_of">
				documentation = <"Create new instance of a type.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Any">
				>
				parameters = <
					["a_type"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_type">
						type = <"String">
					>
				>
			>
			["type_of"] = <
				name = <"type_of">
				documentation = <"Type name of an object as a string. May include generic parameters, as in \"Interval<Time>\".">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
				parameters = <
					["an_object"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"an_object">
						type = <"Any">
					>
				>
			>
		>
	>
	["Temporal"] = <
		name = <"Temporal">
		documentation = <"Abstract ancestor type of Date/Time types.">
		ancestors = <"Ordered", "Time_Definitions">
		is_abstract = <True>
	>
	["Date"] = <
		name = <"Date">
		documentation = <"Assumed built-in primitive type representing a date.">
		ancestors = <"IDate", ...>
		properties = <
			["value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"value">
				documentation = <"Internal private data value of a native Date. No assumption is made about either the naming of this attribute or its type, or if more than one attribute is used.">
				is_mandatory = <True>
				type = <"Any">
			>
		>
	>
	["Date_time"] = <
		name = <"Date_time">
		documentation = <"Assumed built-in primitive type representing a date/time.">
		ancestors = <"IDate_time", ...>
		properties = <
			["value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"value">
				documentation = <"Internal private data value of a native Date/Time. No assumption is made about either the naming of this attribute or its type, or if more than one attribute is used.">
				is_mandatory = <True>
				type = <"Any">
			>
		>
	>
	["Time"] = <
		name = <"Time">
		documentation = <"Assumed built-in primitive type representing a time.">
		ancestors = <"ITime", ...>
		properties = <
			["value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"value">
				documentation = <"Internal private data value of a native Time. No assumption is made about either the naming of this attribute or its type, or if more than one attribute is used.">
				is_mandatory = <True>
				type = <"Any">
			>
		>
	>
	["Duration"] = <
		name = <"Duration">
		documentation = <"Assumed built-in primitive type representing a duration.">
		ancestors = <"IDuration", ...>
		properties = <
			["value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"value">
				documentation = <"Internal private data value of a native Duration. No assumption is made about either the naming of this attribute or its type, or if more than one attribute is used.">
				is_mandatory = <True>
				type = <"Any">
			>
		>
	>
	["Hash"] = <
		name = <"Hash">
		documentation = <"Type representing a keyed table of values. T is the value type, and U the type of the keys. ">
		ancestors = <"Aggregate", ...>
		generic_parameter_defs = <
			["K"] = <
				name = <"K">
				conforms_to_type = <"Ordered">
			>
			["V"] = <
				name = <"V">
			>
		>
		functions = <
			["has_key"] = <
				name = <"has_key">
				documentation = <"Test for membership of a key.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_key"] = (P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN) <
						name = <"a_key">
						type = <"K">
					>
				>
			>
			["item"] = <
				name = <"item">
				documentation = <"Return item for key  a_key'.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"V">
				>
				parameters = <
					["a_key"] = (P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN) <
						name = <"a_key">
						type = <"K">
					>
				>
			>
		>
	>
	["List"] = <
		name = <"List">
		documentation = <"Ordered container that may contain duplicates.">
		ancestors = <"Aggregate", ...>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Any">
			>
		>
		functions = <
			["first"] = <
				name = <"first">
				documentation = <"Return first element.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"T">
				>
			>
			["last"] = <
				name = <"last">
				documentation = <"Return last element.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"T">
				>
			>
		>
		invariants = <
			["First_validity"] = <"not is_empty implies first /= Void">
			["Last_validity"] = <"not is_empty implies last /= Void">
		>
	>
	["Set"] = <
		name = <"Set">
		documentation = <"Unordered container that may not contain duplicates.">
		ancestors = <"Aggregate", ...>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Any">
			>
		>
	>
	["Array"] = <
		name = <"Array">
		documentation = <"Container whose storage is assumed to be contiguous.">
		ancestors = <"Aggregate", ...>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Any">
			>
		>
	>
	["Uri"] = <
		name = <"Uri">
		ancestors = <"Any", ...>
	>
	["Ordered_Numeric"] = <
		name = <"Ordered_Numeric">
		documentation = <"Abstract notional parent class of ordered, numeric types, which are types with ‘<‘ and arithmetic operators defined.">
		ancestors = <"Ordered", "Numeric">
		is_abstract = <True>
	>
	["Integer"] = <
		name = <"Integer">
		documentation = <"Class representing minimal interface of standard Integer type.">
		ancestors = <"Ordered_Numeric", ...>
	>
	["Double"] = <
		name = <"Double">
		ancestors = <"Ordered_Numeric", ...>
	>
	["Numeric"] = <
		name = <"Numeric">
		documentation = <"Abstract notional parent class of numeric types, which are types which have various arithmetic and comparison operators defined.">
		ancestors = <"Any", ...>
		is_abstract = <True>
		functions = <
			["infix *"] = <
				name = <"infix *">
				documentation = <"Product by `other'. Actual type of result depends on arithmetic balancing rules.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Numeric">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Numeric">
					>
				>
			>
			["infix +"] = <
				name = <"infix +">
				documentation = <"Sum with `other' (commutative). Actual type of result depends on arithmetic balancing rules.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Numeric">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Numeric">
					>
				>
			>
			["infix -"] = <
				name = <"infix -">
				documentation = <"Result of subtracting `other'. Actual type of result depends on arithmetic balancing rules.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Numeric">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Numeric">
					>
				>
			>
		>
	>
	["Octet"] = <
		name = <"Octet">
		ancestors = <"Ordered", ...>
	>
	["Character"] = <
		name = <"Character">
		ancestors = <"Ordered", ...>
	>
	["Boolean"] = <
		name = <"Boolean">
		documentation = <"Class representing minimal interface of standard Boolean type.">
		ancestors = <"Any", ...>
		functions = <
			["infix and"] = <
				name = <"infix and">
				documentation = <"Logical conjunction">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Boolean">
					>
				>
				post_conditions = <
					["Post_de_Morgan"] = <"Result = not (not self or not other)">
					["Post_commutative"] = <"Result = (other and self)">
				>
			>
			["infix and_then"] = <
				name = <"infix and_then">
				documentation = <"Boolean semi-strict conjunction with other">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Boolean">
					>
				>
				post_conditions = <
					["Post_de_Morgan"] = <"Result = not (not self or else not other)">
				>
			>
			["infix or"] = <
				name = <"infix or">
				documentation = <"Boolean disjunction with other.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Boolean">
					>
				>
				post_conditions = <
					["Post_de_Morgan"] = <"Result = not (not self and not other)">
					["Post_commutative"] = <"Result = (other or Current)">
					["Post_consistent_with_semi_strict"] = <"Result implies (self or else other)">
				>
			>
			["infix or_else"] = <
				name = <"infix or_else">
				documentation = <"Boolean semi-strict disjunction with `other'.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Boolean">
					>
				>
				post_conditions = <
					["Post_de_Morgan"] = <"Result = not (not self and then not other)">
				>
			>
			["infix xor"] = <
				name = <"infix xor">
				documentation = <"Boolean exclusive or with `other'.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Boolean">
					>
				>
				post_conditions = <
					["Post_definition"] = <"Result = ((self or other) and not (self and other))">
				>
			>
			["infix implies"] = <
				name = <"infix implies">
				documentation = <"Boolean implication of `other' (semi-strict)">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Boolean">
					>
				>
				post_conditions = <
					["Post_definition"] = <"Result = (not self or else other)">
				>
			>
		>
		invariants = <
			["Involutive_negation"] = <"is_equal (not (not self))">
			["Non_contradiction"] = <"not (self and (not self))">
			["Completeness"] = <"self or else (not self)">
		>
	>
	["String"] = <
		name = <"String">
		documentation = <"Strings of characters, as used to represent textual data in any natural or formal language.">
		ancestors = <"Ordered", ...>
		functions = <
			["infix +"] = <
				name = <"infix +">
				documentation = <"Concatenation operator - causes ‘other’ to be appended to this string.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"String">
					>
				>
			>
			["is_empty"] = <
				name = <"is_empty">
				documentation = <"True if string is empty, i.e. equal to \"\".">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_integer"] = <
				name = <"is_integer">
				documentation = <"True if string can be parsed as an integer.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["as_integer"] = <
				name = <"as_integer">
				documentation = <"Return the integer corresponding to the integer value represented in this string.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
		>
	>
	["Real"] = <
		name = <"Real">
		documentation = <"Type used to represent decimal numbers. Corresponds to a single-precision floating point value in most languages.">
		ancestors = <"Ordered_Numeric", ...>
		functions = <
			["floor"] = <
				name = <"floor">
				documentation = <"Return the greatest integer no greater than the value of this object.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
		>
	>
	["Integer64"] = <
		name = <"Integer64">
		documentation = <"Class representing minimal interface of standard Integer64 type.">
		ancestors = <"Ordered_Numeric", ...>
	>
	["Ordered"] = <
		name = <"Ordered">
		documentation = <"Abstract notional parent class of ordered, types i.e. types on which the ‘<‘ operator is defined.">
		ancestors = <"Any", ...>
		is_abstract = <True>
		functions = <
			["infix <"] = <
				name = <"infix <">
				documentation = <"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.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Ordered">
					>
				>
			>
		>
	>
	["Iso8601_date_time"] = <
		name = <"Iso8601_date_time">
		documentation = <"Represents an ISO 8601 date/time, including partial and extended forms.

Note that this class includes 2 deviations from ISO 8601:2004:

* for partial date/times, any part of the date/time up to the month may be missing, not just seconds and minutes as in the standard;
* the time 24:00:00 is not allowed, since it would mean the date was really on the next day.">
		ancestors = <"Iso8601_type", "IDate_time">
		functions = <
			["month_unknown"] = <
				name = <"month_unknown">
				documentation = <"Indicates whether month in year is unknown.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["day_unknown"] = <
				name = <"day_unknown">
				documentation = <"Indicates whether day in month is unknown.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["minute_unknown"] = <
				name = <"minute_unknown">
				documentation = <"Indicates whether minute in hour is known.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["second_unknown"] = <
				name = <"second_unknown">
				documentation = <"Indicates whether minute in hour is known.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_decimal_sign_comma"] = <
				name = <"is_decimal_sign_comma">
				documentation = <"True if this time has a decimal part indicated by ‘,’ (comma) rather than ‘.’ (period).">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["valid_iso8601_date_time"] = <
				name = <"valid_iso8601_date_time">
				documentation = <"String is a valid ISO 8601 date-time, i.e. takes the form:

* YYYYMMDDThhmmss[(,|.)s+][Z|±hh[mm]]

or the extended form:

* YYYY-MM-DDThh:mm:ss[(,|.)s+][Z|±hh[:mm]]

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.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["s"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"s">
						type = <"String">
					>
				>
			>
			["is_partial"] = <
				name = <"is_partial">
				documentation = <"True if this date time is partial, i.e. if seconds or more is missing.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_extended"] = <
				name = <"is_extended">
				documentation = <"True if this date/time uses ‘-’, ‘:’ separators.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["as_string"] = <
				name = <"as_string">
				documentation = <"ISO8601 string for date/time, in format:

* `YYYYMMDDThhmmss[,sss][Z | ±hh[mm]]` 

or in extended format:

* `YYYY-MM-DDThh:mm:ss[,sss][Z | ±hh[mm]]`

or a partial variant; see `_valid_iso8601_date_time()_` for validity.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["has_fractional_second"] = <
				name = <"has_fractional_second">
				documentation = <"True if the fractional_second part is signficant (i.e. even if = 0.0).">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["as_date_time"] = <
				name = <"as_date_time">
				documentation = <"Convert to a native `Date_time`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Date_time">
				>
			>
		>
		invariants = <
			["Year_valid"] = <"valid_year (year)">
			["Month_valid"] = <"valid_month (month)">
			["Day_valid"] = <"valid_day(year, month, day)">
			["Hour_valid"] = <"valid_hour (hour, minute, second)">
			["Minute_valid"] = <"not minute_unknown implies valid_minute(minute)">
			["Second_valid"] = <"not second_unknown implies valid_second (second)">
			["Fractional_second_valid"] = <"has_fractional_second implies (not second_unknown and valid_fractional_second (fractional_second))">
			["Partial_validity_year"] = <"not month_unknown">
			["Partial_validity_month"] = <"not month_unknown">
			["Partial_validity_day"] = <"not day_unknown">
			["Partial_validity_hour"] = <"not hour_unknown">
			["Partial_validity_minute"] = <"minute_unknown implies second_unknown">
		>
	>
	["Iso8601_duration"] = <
		name = <"Iso8601_duration">
		documentation = <"Represents an ISO 8601 duration, which may have multiple parts from years down to seconds.">
		ancestors = <"Iso8601_type", "IDuration">
		functions = <
			["is_decimal_sign_comma"] = <
				name = <"is_decimal_sign_comma">
				documentation = <"True if this time has a decimal part indicated by ',' (comma) rather than '.' (period).">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["valid_iso8601_duration"] = <
				name = <"valid_iso8601_duration">
				documentation = <"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).">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["s"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"s">
						documentation = <"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).">
						type = <"String">
					>
				>
			>
			["is_partial"] = <
				name = <"is_partial">
				documentation = <"Returns False.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_extended"] = <
				name = <"is_extended">
				documentation = <"Returns True.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["as_string"] = <
				name = <"as_string">
				documentation = <"ISO8601 string for duration, in format

* `P[nnY][nnM][nnW][nnD][T[nnH][nnM][nnS]]`">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["months"] = <
				name = <"months">
				documentation = <"Number of months.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["years"] = <
				name = <"years">
				documentation = <"Number of years of nominal 365-day length.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["weeks"] = <
				name = <"weeks">
				documentation = <"Number of 7 day weeks.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["to_seconds"] = <
				name = <"to_seconds">
				documentation = <"Total number of seconds equivalent (including fractional) of entire duration.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["minutes"] = <
				name = <"minutes">
				documentation = <"Number of 60 second minutes.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["hours"] = <
				name = <"hours">
				documentation = <"Number of 60 minute hours.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["days"] = <
				name = <"days">
				documentation = <"Number of 24 hour days.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["as_duration"] = <
				name = <"as_duration">
				documentation = <"Convert to a native `Duration`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Duration">
				>
			>
		>
		invariants = <
			["Years_valid"] = <"years >= 0">
			["Months_valid"] = <"months >= 0">
			["Weeks_valid"] = <"weeks >= 0">
			["Days_valid"] = <"days >= 0">
			["Hours_valid"] = <"hours >= 0">
			["Minutes_valid"] = <"minutes >= 0">
			["Seconds_valid"] = <"seconds >= 0">
			["Fractional_second_valid"] = <"fractional_second >= 0.0 and fractional_second < 1.0">
		>
	>
	["Iso8601_time"] = <
		name = <"Iso8601_time">
		documentation = <"Represents an ISO 8601 time, including partial and extended forms.

NOTE: A small deviation to the ISO 8601:2004 standard in this class is that the time 24:00:00 is not allowed, for consistency with ISO8601_DATE_TIME.">
		ancestors = <"Iso8601_type", "ITime">
		functions = <
			["minute_unknown"] = <
				name = <"minute_unknown">
				documentation = <"Indicates whether minute is unknown. If so, the time is of the form “hh”.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["second_unknown"] = <
				name = <"second_unknown">
				documentation = <"Indicates whether second is unknown. If so and month is known, the time is of the form “hh:mm” or “hhmm”.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_decimal_sign_comma"] = <
				name = <"is_decimal_sign_comma">
				documentation = <"True if this time has a decimal part indicated by ‘,’ (comma) rather than ‘.’ (period).">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["valid_iso8601_time"] = <
				name = <"valid_iso8601_time">
				documentation = <"String is a valid ISO 8601 date, i.e. takes the form:

* hhmmss[(,|.)s+][Z|±hh[mm]]

or the extended form:

* hh:mm:ss[(,|.)s+][Z|±hh[:mm]]

or one of the partial forms:

* hhmm or hh 

or the extended form:

* hh:mm

with an additional optional timezone indicator of:

* Z or ±hh[mm] or ±hh[:mm] (extended form)

Where:

* hh is “00” - “23” (0-filled to two digits)
* mm is “00” - “59” (0-filled to two digits)
* ss is “00” - “60” (0-filled to two digits)
* [(,|.)s+] is an optional string consisting of a comma or decimal point followed by numeric string of 1 or more digits, representing a fractional second
* Z is a literal meaning UTC (modern replacement for GMT), i.e. timezone +0000">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_partial"] = <
				name = <"is_partial">
				documentation = <"True if this time is partial, i.e. if seconds or more is missing.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_extended"] = <
				name = <"is_extended">
				documentation = <"True if this time uses ‘-’, ‘:’ separators.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["as_string"] = <
				name = <"as_string">
				documentation = <"ISO8601 string for time, i.e. in the form:

* `hhmmss[,sss][Z|±hh[mm]]`

or the extended form: 

* `hh:mm:ss[,sss][Z|±hh[mm]]`

or a partial invariant. See `_valid_iso8601_time()_` for validity.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["has_fractional_second"] = <
				name = <"has_fractional_second">
				documentation = <"True if the fractional_second part is signficant (i.e. even if = 0.0).">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["as_time"] = <
				name = <"as_time">
				documentation = <"Convert to a native `Time`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Time">
				>
			>
		>
		invariants = <
			["Hour_valid"] = <"valid_hour(hour, minute, second)">
			["Minute_valid"] = <"not minute_unknown implies valid_minute (minute)">
			["Second_valid"] = <"not second_unknown implies valid_second (second)">
			["Fractional_second_valid"] = <"has_fractional_second implies (not second_unknown and valid_fractional_second (fractional_second))">
			["Partial_validity"] = <"minute_unknown implies second_unknown">
		>
	>
	["Iso8601_type"] = <
		name = <"Iso8601_type">
		documentation = <"Abstract ancestor type of ISO 8601 types, defining interface for 'extended' and 'partial' concepts from ISO 8601.">
		ancestors = <"Ordered", ...>
		is_abstract = <True>
		properties = <
			["value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"value">
				is_mandatory = <True>
				type = <"String">
			>
		>
		functions = <
			["is_partial"] = <
				name = <"is_partial">
				documentation = <"True if this date time is partial, i.e. if trailing end (right hand) value(s) is/are missing.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_extended"] = <
				name = <"is_extended">
				documentation = <"True if this ISO8601 string is in the 'extended' form, i.e. uses ‘-’ and / or ‘:’ separators.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
	>
	["Iso8601_date"] = <
		name = <"Iso8601_date">
		documentation = <"Represents an ISO 8601 date, including partial and extended forms.">
		ancestors = <"Iso8601_type", "IDate">
		functions = <
			["month_unknown"] = <
				name = <"month_unknown">
				documentation = <"Indicates whether month in year is unknown. If so, the date is of the form “YYYY”.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["day_unknown"] = <
				name = <"day_unknown">
				documentation = <"Indicates whether day in month is unknown. If so, and month is known, the date is of the form “YYYY-MM” or “YYYYMM”.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["valid_iso8601_date"] = <
				name = <"valid_iso8601_date">
				documentation = <"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 must be correct with respect to the Gregorian calendar.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_partial"] = <
				name = <"is_partial">
				documentation = <"True if this date is partial, i.e. if days or more is missing.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_extended"] = <
				name = <"is_extended">
				documentation = <"True if this date uses `'-'` separators.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["as_string"] = <
				name = <"as_string">
				documentation = <"ISO8601 string for date, in format `YYYYMMDD` or `YYYY-MM-DD`, or a partial invariant. See `_valid_iso8601_date()_` for validity.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["as_date"] = <
				name = <"as_date">
				documentation = <"Convert to a native `Date`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Date">
				>
			>
		>
		invariants = <
			["Year_valid"] = <"valid_year (year)">
			["Month_valid"] = <"not month_unknown implies valid_month (month)">
			["Day_valid"] = <"not day_unknown implies valid_day (year, month, day)">
			["Partial_validity"] = <"month_unknown implies day_unknown">
		>
	>
	["Multiplicity_interval"] = <
		name = <"Multiplicity_interval">
		documentation = <"An Interval of Integer, used to represent multiplicity, cardinality and optionality in models. ">
		ancestors = <"Proper_interval", ...>
		constants = <
			["Multiplicity_range_marker"] = <
				name = <"Multiplicity_range_marker">
				documentation = <"Marker to use in string form of interval between limits.">
				type = <"String">
				value = <"\"..\"">
			>
			["Multiplicity_unbounded_marker"] = <
				name = <"Multiplicity_unbounded_marker">
				documentation = <"Symbol to use to indicate upper limit unbounded.">
				type = <"Character">
				value = <"'*'">
			>
		>
		functions = <
			["is_open"] = <
				name = <"is_open">
				documentation = <"True if this interval imposes no constraints, i.e. is set to 0..*">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_optional"] = <
				name = <"is_optional">
				documentation = <"True if this interval expresses optionality, i.e. 0..1.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_mandatory"] = <
				name = <"is_mandatory">
				documentation = <"True if this interval expresses mandation, i.e. 1..1.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_prohibited"] = <
				name = <"is_prohibited">
				documentation = <"True if this interval is set to 0..0.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
	>
	["Interval"] = <
		name = <"Interval">
		documentation = <"Interval abstraction, featuring upper and lower limits that may be open or closed, included or not included.">
		ancestors = <"Any", ...>
		is_abstract = <True>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Ordered">
			>
		>
		properties = <
			["lower"] = (P_BMM_SINGLE_PROPERTY_OPEN) <
				name = <"lower">
				documentation = <"lower bound.">
				type = <"T">
			>
			["lower_unbounded"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"lower_unbounded">
				documentation = <"lower boundary open (i.e. = -infinity)">
				is_mandatory = <True>
				type = <"Boolean">
			>
			["upper_unbounded"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"upper_unbounded">
				documentation = <"upper boundary open (i.e. = +infinity)">
				is_mandatory = <True>
				type = <"Boolean">
			>
			["lower_included"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"lower_included">
				documentation = <"lower boundary value included in range if not lower_unbounded.">
				is_mandatory = <True>
				type = <"Boolean">
			>
			["upper_included"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"upper_included">
				documentation = <"upper boundary value included in range if not upper_unbounded.">
				is_mandatory = <True>
				type = <"Boolean">
			>
		>
		functions = <
			["has"] = <
				name = <"has">
				documentation = <"True if (lower_unbounded or 
((lower_included and v >= lower) or 
v > lower)) and 
(upper_unbounded or 
((upper_included and v <= upper or v 
< upper)))">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["e"] = (P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN) <
						name = <"e">
						type = <"T">
					>
				>
			>
			["intersects"] = <
				name = <"intersects">
				documentation = <"True if there is any overlap between intervals represented by Current and `other'. True if at least one limit of other is strictly inside the limits of this interval.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Interval">
					>
				>
			>
			["contains"] = <
				name = <"contains">
				documentation = <"True if current interval properly contains `other'? True if all points of `other' are inside the current interval.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Interval">
					>
				>
			>
			["is_equal"] = <
				name = <"is_equal">
				documentation = <"True if current object's interval is semantically same as `other'.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"Any">
					>
				>
			>
			["upper"] = <
				name = <"upper">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"T">
				>
				is_nullable = <True>
			>
		>
		invariants = <
			["Lower_included_valid"] = <"lower_unbounded implies not lower_included">
			["Upper_included_valid"] = <"upper_unbounded implies not upper_included">
			["Limits_consistent"] = <"(not upper_unbounded and not lower_unbounded) implies lower <= upper">
			["Limits_comparable"] = <"(not upper_unbounded and not lower_unbounded) implies lower.strictly_comparable_to (upper)">
		>
	>
	["Cardinality"] = <
		name = <"Cardinality">
		documentation = <"Express 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.">
		properties = <
			["interval"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"interval">
				documentation = <"The interval of this cardinality. ">
				is_mandatory = <True>
				type = <"Multiplicity_interval">
			>
			["is_ordered"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_ordered">
				documentation = <"True if the members of the container attribute to which this cardinality refers are ordered. ">
				is_mandatory = <True>
				type = <"Boolean">
			>
			["is_unique"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_unique">
				documentation = <"True if the members of the container attribute to which this cardinality refers are unique.">
				is_mandatory = <True>
				type = <"Boolean">
			>
		>
		functions = <
			["is_bag"] = <
				name = <"is_bag">
				documentation = <"True if the semantics of this cardinality represent a bag, i.e. unordered, non-unique membership.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_list"] = <
				name = <"is_list">
				documentation = <"True if the semantics of this cardinality represent a list, i.e. ordered, non-unique membership.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_set"] = <
				name = <"is_set">
				documentation = <"True if the semantics of this cardinality represent a set, i.e. unordered, unique membership.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
	>
>
class_definitions = <
	["ARCHETYPE_ID"] = <
		name = <"ARCHETYPE_ID">
		documentation = <"Identifier for archetypes. Ideally these would identify globally unique archetypes.
Lexical form: `rm_originator  '-' rm_name  '-' rm_entity  '.' concept_name {  '-' specialisation }*  '.v' number`.">
		ancestors = <"OBJECT_ID", ...>
		functions = <
			["qualified_rm_entity"] = <
				name = <"qualified_rm_entity">
				documentation = <"Globally qualified reference model entity, e.g.  openehr-composition-OBSERVATION.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["domain_concept"] = <
				name = <"domain_concept">
				documentation = <"Name of the concept represented by this archetype, including specialisation, e.g. 
 Biochemistry_result-cholesterol . ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["rm_originator"] = <
				name = <"rm_originator">
				documentation = <"Organisation originating the reference model on which this archetype is based, e.g. 
 openehr ,  cen ,  hl7 . ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["rm_name"] = <
				name = <"rm_name">
				documentation = <"Name of the reference model, e.g. rim,  ehr_rm,  en13606 . ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["rm_entity"] = <
				name = <"rm_entity">
				documentation = <"Name of the ontological level within the reference model to which this archetype is targeted, e.g. for openEHR,  folder ,  composition ,  section ,  entry .">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["specialisation"] = <
				name = <"specialisation">
				documentation = <"Name of specialisation of concept, if this archetype is a specialisation of another archetype, e.g.  cholesterol .">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["version_id"] = <
				name = <"version_id">
				documentation = <"Version of this archetype. 
">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
	>
	["GENERIC_ID"] = <
		name = <"GENERIC_ID">
		documentation = <"Generic identifier type for identifiers whose format is otherwise unknown to openEHR. Includes an attribute for naming the identification scheme (which may well be local). ">
		ancestors = <"OBJECT_ID", ...>
		properties = <
			["scheme"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"scheme">
				documentation = <"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. ">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["HIER_OBJECT_ID"] = <
		name = <"HIER_OBJECT_ID">
		documentation = <"Concrete type corresponding to hierarchical identifiers of the form defined by UID_BASED_ID. ">
		ancestors = <"UID_BASED_ID", ...>
	>
	["LOCATABLE_REF"] = <
		name = <"LOCATABLE_REF">
		documentation = <"Purpose Reference to a LOCATABLE instance inside the top-level content structure inside a VERSION<T>; the path attribute is applied to the object that VERSION.data points to. ">
		ancestors = <"OBJECT_REF", ...>
		properties = <
			["path"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"path">
				documentation = <"The path to an instance in question, as an absolute path with respect to the object found at VERSION.data. An empty path means that the object referred to by id being specified. ">
				type = <"String">
			>
			["id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"id">
				documentation = <"The identifier of the Version. ">
				is_mandatory = <True>
				type = <"UID_BASED_ID">
			>
		>
		functions = <
			["as_uri"] = <
				name = <"as_uri">
				documentation = <"A URI form of the reference, created by concatenating the following: `ehr://  + id.value +  /  + path`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
	>
	["OBJECT_ID"] = <
		name = <"OBJECT_ID">
		documentation = <"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 ids are used inside an object to identify that object. To identify another object in another service, use an OBJECT_REF, or else use a UID for local objects identified by UID. If none of the subtypes is suitable, direct instances of this class may be used. ">
		is_abstract = <True>
		properties = <
			["value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"value">
				documentation = <"The value of the id in the form defined below. ">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["OBJECT_REF"] = <
		name = <"OBJECT_REF">
		documentation = <"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. ">
		properties = <
			["namespace"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"namespace">
				documentation = <"Namespace to which this identifier belongs in 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-zA-Z][a-zA-Z0-9_-:/&+?]*
">
				is_mandatory = <True>
				type = <"String">
			>
			["type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type">
				documentation = <"Name of the  class (concrete or abstract) 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). ">
				is_mandatory = <True>
				type = <"String">
			>
			["id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"id">
				documentation = <"Globally unique id of an object, regardless of where it is stored.">
				is_mandatory = <True>
				type = <"OBJECT_ID">
			>
		>
	>
	["OBJECT_VERSION_ID"] = <
		name = <"OBJECT_VERSION_ID">
		documentation = <"Globally unique identifier for one version of a versioned object; lexical form: `object_id  '::' creating_system_id  '::' version_tree_id`.">
		ancestors = <"UID_BASED_ID", ...>
		functions = <
			["object_id"] = <
				name = <"object_id">
				documentation = <"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. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"UID">
				>
			>
			["version_tree_id"] = <
				name = <"version_tree_id">
				documentation = <"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 . ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VERSION_TREE_ID">
				>
			>
			["creating_system_id"] = <
				name = <"creating_system_id">
				documentation = <"Identifier of the system that created the Version corresponding to this Object version id.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"UID">
				>
			>
			["is_branch"] = <
				name = <"is_branch">
				documentation = <"True if this version identifier represents a branch.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
	>
	["PARTY_REF"] = <
		name = <"PARTY_REF">
		documentation = <"Identifier for parties in a demographic or identity service. There are typically a number of subtypes of the PARTY class, including PERSON, ORGANISATION, etc. Abstract supertypes are allowed if the referenced object is of a type not known by the current implementation of this class (in other words, if the demographic model is changed by the addition of a new PARTY or ACTOR subtypes, valid PARTY_REFs can still be constructed to them). ">
		ancestors = <"OBJECT_REF", ...>
		invariants = <
			["Type_validity"] = <"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”)">
		>
	>
	["TERMINOLOGY_ID"] = <
		name = <"TERMINOLOGY_ID">
		documentation = <"Identifier for terminologies such as 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.

Lexical form: `name [  (' version  )' ]`.
">
		ancestors = <"OBJECT_ID", ...>
		functions = <
			["name"] = <
				name = <"name">
				documentation = <"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. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["version_id"] = <
				name = <"version_id">
				documentation = <"Version of this terminology, if versioning supported, else the empty string. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
	>
	["VERSION_TREE_ID"] = <
		name = <"VERSION_TREE_ID">
		documentation = <"Version tree identifier for one version. Lexical form: 

`trunk_version [  '.' branch_number  '.' branch_version ]`">
		properties = <
			["value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"value">
				documentation = <"String form of this identifier.">
				is_mandatory = <True>
				type = <"String">
			>
		>
		functions = <
			["trunk_version"] = <
				name = <"trunk_version">
				documentation = <"Trunk version number; numbering starts at 1. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["is_branch"] = <
				name = <"is_branch">
				documentation = <"True if this version identifier represents a branch, i.e. has branch_number and branch_version parts.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["branch_number"] = <
				name = <"branch_number">
				documentation = <"Number of branch from the trunk point; numbering starts at 1. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["branch_version"] = <
				name = <"branch_version">
				documentation = <"Version of the branch; numbering starts at 1. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
		invariants = <
			["Value_valid"] = <"not value.is_empty">
			["Trunk_version_valid"] = <"trunk_version /= Void and then trunk_version.is_integer and then trunk_version.as_integer >= 1">
			["Branch_number_valid"] = <"branch_number /= Void implies branch_number.is_integer and then branch_number.as_integer >= 1">
			["Branch_version_valid"] = <"branch_version /= Void implies branch_version.is_integer and then branch_version.as_integer >= 1">
			["Branch_validity"] = <"(branch_number = Void and branch_version = Void ) xor (branch_number /= Void and branch_version /= Void )">
			["Is_branch_validity"] = <"is_branch xor branch_number = Void">
			["Is_first_validity"] = <"not is_first xor trunk_version.is_equal(“1”)">
		>
	>
	["UID_BASED_ID"] = <
		name = <"UID_BASED_ID">
		documentation = <"Abstract model of UID-based identifiers consisting of a root part and an optional extension;

lexical form: `root '::' extension`.">
		ancestors = <"OBJECT_ID", ...>
		is_abstract = <True>
		functions = <
			["root"] = <
				name = <"root">
				documentation = <"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. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"UID">
				>
			>
			["extension"] = <
				name = <"extension">
				documentation = <"Optional local identifier of the object within the context of the root identifier. Returns the part to the right of the first  ::' separator if any, or else any empty String.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["has_extension"] = <
				name = <"has_extension">
				documentation = <"True if extension /= Void.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
		invariants = <
			["Has_extension_valid"] = <"extension.is_empty xor has_extension">
		>
	>
	["UUID"] = <
		name = <"UUID">
		documentation = <"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.">
		ancestors = <"UID", ...>
	>
	["INTERNET_ID"] = <
		name = <"INTERNET_ID">
		documentation = <"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). ">
		ancestors = <"UID", ...>
	>
	["UID"] = <
		name = <"UID">
		documentation = <"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 and are never re-used.">
		is_abstract = <True>
		properties = <
			["value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"value">
				documentation = <"The value of the id.">
				is_mandatory = <True>
				type = <"String">
			>
		>
		invariants = <
			["Value_valid"] = <"not value.empty">
		>
	>
	["ISO_OID"] = <
		name = <"ISO_OID">
		documentation = <"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. ">
		ancestors = <"UID", ...>
	>
	["TEMPLATE_ID"] = <
		name = <"TEMPLATE_ID">
		documentation = <"Identifier for templates. Lexical form to be determined.">
		ancestors = <"OBJECT_ID", ...>
	>
	["ACCESS_GROUP_REF"] = <
		name = <"ACCESS_GROUP_REF">
		documentation = <"Reference to access group in an access control service.">
		ancestors = <"OBJECT_REF", ...>
		invariants = <
			["Type_validity"] = <"type.is_equal (“ACCESS_GROUP”)">
		>
	>
	["OPENEHR_DEFINITIONS"] = <
		name = <"OPENEHR_DEFINITIONS">
		documentation = <"Inheritance class to provide access to constants defined in other packages.">
		ancestors = <"BASIC_DEFINITIONS", ...>
		constants = <
			["Local_terminology_id"] = <
				name = <"Local_terminology_id">
				documentation = <"Predefined terminology identifier to indicate it is local to the knowledge resource in which it occurs, e.g. an archetype">
				type = <"String">
				value = <"\"local\"">
			>
		>
	>
	["BASIC_DEFINITIONS"] = <
		name = <"BASIC_DEFINITIONS">
		documentation = <"Defines globally used constant values.">
		constants = <
			["CR"] = <
				name = <"CR">
				documentation = <"Carriage return character.">
				type = <"Character">
				value = <"'\\015'">
			>
			["LF"] = <
				name = <"LF">
				documentation = <"Line feed character.">
				type = <"Character">
				value = <"'\\012'">
			>
			["Any_type"] = <
				name = <"Any_type">
				type = <"String">
				value = <"\"Any\"">
			>
			["Regex_any_pattern"] = <
				name = <"Regex_any_pattern">
				type = <"String">
				value = <"\".*\"">
			>
			["Default_encoding"] = <
				name = <"Default_encoding">
				type = <"String">
				value = <"\"UTF-8\"">
			>
		>
	>
	["VALIDITY_KIND"] = (P_BMM_ENUMERATION_STRING) <
		name = <"VALIDITY_KIND">
		documentation = <"An enumeration of three values that may commonly occur in constraint models.

Use as the type of any attribute within this model, which expresses constraint on some attribute in a class in a reference model. For example to indicate validity
of Date/Time fields.">
		ancestors = <"String", ...>
		item_names = <"mandatory", "optional", "prohibited">
		item_documentations = <"Constant to indicate mandatory presence of something.", "Constant to indicate optional presence of something.", "Constant to indicate disallowed presence of something.">
	>
	["VERSION_STATUS"] = (P_BMM_ENUMERATION_STRING) <
		name = <"VERSION_STATUS">
		documentation = <"Status of a versioned artefact, as one of a number of possible values: uncontrolled, prerelease, release, build.">
		ancestors = <"String", ...>
		item_names = <"alpha", "beta", "release_candidate", "released", "build">
		item_documentations = <"Value representing a version which is 'unstable', i.e. contains an unknown size of change with respect to its base version. Rendered with the build number as a string in the form `N.M.P-alpha.B` e.g. `2.0.1-alpha.154`.", "Value representing a version which is 'beta', i.e. contains an unknown but reducing size of change with respect to its base version. Rendered with the build number as a string in the form `N.M.P-beta.B` e.g. `2.0.1-beta.154`.", "Value representing a version which is 'release candidate', i.e. contains only patch-level changes on the base version. Rendered as a string as `N.M.P-rc.B` e.g. `2.0.1-rc.27`.", "Value representing a version which is 'released', i.e. is the definitive base version. Rendered with the build number as a string in the form `N.M.P` e.g. `2.0.1`.", "Value representing a version which is a build of the current base release. Rendered with the build number as a string in the form `N.M.P+B` e.g. `2.0.1+33`.">
	>
	["BMM_MODEL_ACCESS"] = <
		name = <"BMM_MODEL_ACCESS">
		documentation = <"Access to BMM models that have been loaded and validated from one or more schema sets.">
		ancestors = <"BMM_DEFINITIONS", ...>
		properties = <
			["schema_directories"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"schema_directories">
				documentation = <"List of directories where all the schemas loaded here are found.">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["all_schemas"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"all_schemas">
				documentation = <"All schemas found and loaded from `_schema_directory_`. Keyed by `_schema_id_`.">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["bmm_models"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"bmm_models">
				documentation = <"Top-level (root) schemas in use. Table is keyed by `_model_id_`.">
				type_def = <
					generic_parameters = <"String", "BMM_MODEL">
					root_type = <"Hash">
				>
			>
			["matching_bmm_models"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"matching_bmm_models">
				documentation = <"`BMM_MODELs` keyed by `_model_id()_` and any shorter form used in calls to ">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
		>
		functions = <
			["initialise_with_load_list"] = <
				name = <"initialise_with_load_list">
				documentation = <"Initialise with a specific schema load list, usually a sub-set of schemas that will be found in a specified directories `_a_schema_dirs_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["a_schema_dirs"] = (P_BMM_CONTAINER_FUNCTION_PARAMETER) <
						name = <"a_schema_dirs">
						type_def = <
							container_type = <"List">
							type = <"String">
						>
						cardinality = <|>=1|>
					>
					["a_schema_load_list"] = (P_BMM_CONTAINER_FUNCTION_PARAMETER) <
						name = <"a_schema_load_list">
						type_def = <
							container_type = <"List">
							type = <"String">
						>
						cardinality = <|>=0|>
						is_nullable = <True>
					>
				>
			>
			["initialise_all"] = <
				name = <"initialise_all">
				documentation = <"Load all schemas found in a specified directories `_a_schema_dirs_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["a_schema_dirs"] = (P_BMM_CONTAINER_FUNCTION_PARAMETER) <
						name = <"a_schema_dirs">
						type_def = <
							container_type = <"List">
							type = <"String">
						>
						cardinality = <|>=1|>
					>
				>
			>
			["reload_schemas"] = <
				name = <"reload_schemas">
				documentation = <"Reload BMM schemas.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
			>
			["bmm_model"] = <
				name = <"bmm_model">
				documentation = <"Return ref model containing the model key which is a `_model_id_` or any shorter form e.g. model id minus the version. If a shorter key is used, the `BMM_MODEL` with the highest version will be selected.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_MODEL">
				>
				parameters = <
					["a_model_key"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_model_key">
						type = <"String">
					>
				>
			>
			["has_bmm_model"] = <
				name = <"has_bmm_model">
				documentation = <"True if a model for a `_model_key_` is available. A model key is a `_model_id_` or any shorter form e.g. model id minus the version. If a shorter key is used, the Result s True if a `BMM_MODEL` with any version exists.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_model_key"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_model_key">
						type = <"String">
					>
				>
			>
		>
	>
	["BMM_SCHEMA_DESCRIPTOR"] = <
		name = <"BMM_SCHEMA_DESCRIPTOR">
		documentation = <"Descriptor for a BMM schema. Contains a meta-data table of attributes obtained from a mini-ODIN parse of the  schema file.">
		ancestors = <"BMM_DEFINITIONS", ...>
		is_abstract = <True>
		properties = <
			["bmm_schema"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_schema">
				documentation = <"Persistent form of model.">
				type = <"BMM_SCHEMA">
			>
			["bmm_model"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_model">
				documentation = <"Computable form of model.">
				type = <"BMM_MODEL">
			>
			["schema_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"schema_id">
				documentation = <"Schema id, formed from:

* `meta_data.item(Metadata_model_publisher)` '-' `meta_data.item(metadata_schema_name)` '-' `meta_data.item(Metadata_model_release)`

e.g. `openehr_rm_1.0.3`, `openehr_test_1.0.1`, `iso_13606_1_2008_2.1.2`.">
				is_mandatory = <True>
				type = <"String">
			>
			["meta_data"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"meta_data">
				documentation = <"Table of `{key, value}` pairs of schema meta-data, keys are string values corresponding to values in `P_BMM_SCHEMA_METADATA_KEY`.">
				is_mandatory = <True>
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
			["includes"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"includes">
				documentation = <"Identifiers of schemas included by this schema.">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
		>
		functions = <
			["is_top_level"] = <
				name = <"is_top_level">
				documentation = <"True if this is a top-level schema, i.e. not included by some other schema.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_bmm_compatible"] = <
				name = <"is_bmm_compatible">
				documentation = <"True if the BMM version found in the schema (or assumed, if none) is compatible with that in this software.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["load"] = <
				name = <"load">
				documentation = <"Load schema into in-memory form, i.e. a `P_BMM_SCHEMA` instance, if structurally valid. If successful, `_p_schema_` will be set.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
			>
			["validate_merged"] = <
				name = <"validate_merged">
				documentation = <"Validate loaded schema and report errors.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
			>
			["validate_includes"] = <
				name = <"validate_includes">
				documentation = <"Validate includes list for this schema, to see if each mentioned schema exists in `_all_schemas_` list.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["all_schemas_list"] = (P_BMM_CONTAINER_FUNCTION_PARAMETER) <
						name = <"all_schemas_list">
						type_def = <
							container_type = <"List">
							type = <"String">
						>
						cardinality = <|>=0|>
						is_nullable = <True>
					>
				>
			>
			["create_model"] = <
				name = <"create_model">
				documentation = <"Create `schema`, i.e. the `BMM_MODEL` from one `P_BMM_SCHEMA` schema.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
			>
		>
	>
	["BMM_SCHEMA"] = <
		name = <"BMM_SCHEMA">
		documentation = <"Parent of pesistable forms of `BMM_MODEL`. Defines the abstract interface and some common implementation elements for descendants, which provide concrete persistence formats.">
		ancestors = <"P_BMM_PACKAGE_CONTAINER", "BMM_MODEL_METADATA">
		is_abstract = <True>
		properties = <
			["bmm_version"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_version">
				documentation = <"Version of BMM model, enabling schema evolution reasoning. Persisted attribute.">
				is_mandatory = <True>
				type = <"String">
			>
			["primitive_types"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"primitive_types">
				documentation = <"Primitive type definitions. Persisted attribute.">
				type_def = <
					container_type = <"List">
					type = <"P_BMM_CLASS">
				>
				cardinality = <|>=0|>
			>
			["class_definitions"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"class_definitions">
				documentation = <"Class definitions. Persisted attribute.">
				type_def = <
					container_type = <"List">
					type = <"P_BMM_CLASS">
				>
				cardinality = <|>=0|>
			>
			["includes"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"includes">
				documentation = <"Inclusion list, in the form of a hash of individual include specifications, each of which at least specifies the id of another schema, and may specify a namespace via which types from the included schemas are known in this schema.
Persisted attribute.">
				type_def = <
					generic_parameters = <"String", "BMM_INCLUDE_SPEC">
					root_type = <"Hash">
				>
			>
			["bmm_schema"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_schema">
				documentation = <"Generated by create_bmm_schema from persisted elements.">
				type = <"BMM_MODEL">
			>
			["state"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"state">
				documentation = <"Current processing state.">
				is_mandatory = <True>
				type = <"BMM_SCHEMA_STATE">
			>
			["model_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"model_name">
				documentation = <"Name of this model, if this schema is a model root point. Not set for sub-schemas that are not considered models on their own.">
				type = <"String">
			>
			["schema_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"schema_name">
				documentation = <"Name of model expressed in schema; a 'schema' usually contains all of the packages of one 'model' of a publisher. A publisher with more than one model can have multiple schemas. ">
				is_mandatory = <True>
				type = <"String">
			>
			["schema_revision"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"schema_revision">
				documentation = <"Revision of schema.">
				is_mandatory = <True>
				type = <"String">
			>
			["schema_lifecycle_state"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"schema_lifecycle_state">
				documentation = <"Schema development lifecycle state. ">
				is_mandatory = <True>
				type = <"String">
			>
			["schema_author"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"schema_author">
				documentation = <"Primary author of schema. ">
				is_mandatory = <True>
				type = <"String">
			>
			["schema_description"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"schema_description">
				documentation = <"Description of schema. ">
				is_mandatory = <True>
				type = <"String">
			>
			["schema_contributors"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"schema_contributors">
				documentation = <"Contributing authors of schema. ">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
		>
		functions = <
			["validate_created"] = <
				name = <"validate_created">
				documentation = <"Do some basic validation post initial creation

* check that package structure is regular:
** only top-level packages can have qualified names
** no top-level package name can be a direct parent or child of another (child package must be declared under the parent)
* check that all classes are mentioned in the package structure
* check that all models refer to valid packages">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				pre_conditions = <
					["Pre_state"] = <"state = State_created">
				>
				post_conditions = <
					["Post_state"] = <"passed implies state = State_validated_created">
				>
			>
			["load_finalise"] = <
				name = <"load_finalise">
				documentation = <"Finalisation work:

* convert packages to canonical form, i.e. full hierarchy with no packages with names like aa.bb.cc
* set up include processing list">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				pre_conditions = <
					["Pre_state"] = <"state = State_validated_created">
				>
				post_conditions = <
					["Post_state"] = <"state = State_includes_processed or state = State_includes_pending">
				>
			>
			["merge"] = <
				name = <"merge">
				documentation = <"Merge in class and package definitions from `_other_`, except where the current schema already has a definition for the given type or package.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"BMM_SCHEMA">
					>
				>
				pre_conditions = <
					["Pre_state"] = <"state = State_includes_pending">
					["Pre_other_valid"] = <"includes_to_process.has (included_schema.schema_id)">
				>
			>
			["validate"] = <
				name = <"validate">
				documentation = <"Main validation prior to generation of `_bmm_model_`.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
			>
			["create_bmm_model"] = <
				name = <"create_bmm_model">
				documentation = <"Populate `_bmm_model_` from schema.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				pre_conditions = <
					["Pre_state"] = <"state = P_BMM_PACKAGE_STATE.State_includes_processed">
				>
			>
			["read_to_validate"] = <
				name = <"read_to_validate">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post_state"] = <"state = State_includes_processed">
				>
			>
			["schema_id"] = <
				name = <"schema_id">
				documentation = <"Identifier of this schema, used for stating inclusions and identifying files. Formed as:

`_rm_publisher_ '_' _schema_name_ '_' _rm_release_`

E.g. `'openehr_rm_ehr_1.0.4'`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
	>
	["P_BMM_SCHEMA_DESCRIPTOR"] = <
		name = <"P_BMM_SCHEMA_DESCRIPTOR">
		documentation = <"Concrete descendant of `BMM_SCHEMA_DESCRIPTOR` that provides a way to read an ODIN or other similarly encoded P_BMM schema file.">
		ancestors = <"BMM_SCHEMA_DESCRIPTOR", ...>
		properties = <
			["bmm_schema"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_schema">
				documentation = <"Persistent form of model.">
				type = <"P_BMM_SCHEMA">
			>
		>
	>
	["BMM_SCHEMA_METADATA_KEY"] = (P_BMM_ENUMERATION_STRING) <
		name = <"BMM_SCHEMA_METADATA_KEY">
		ancestors = <"String", ...>
		item_names = <"bmm_version", "model_publisher", "schema_name", "model_release", "schema_revision", "schema_lifecycle_state", "schema_description", "schema_path">
		item_documentations = <"", "", "", "", "", "", "", "">
	>
	["BMM_TYPE"] = <
		name = <"BMM_TYPE">
		documentation = <"Abstract idea of specifying a type in some context. This is not the same as 'defining' a class. A type specification is essentially a reference of some kind, that defines the type of an attribute, or function result or argument. It may include generic parameters that might or might not be bound. See subtypes.">
		ancestors = <"BMM_ENTITY", ...>
		is_abstract = <True>
		functions = <
			["effective_base_class"] = <
				name = <"effective_base_class">
				documentation = <"Effective underlying class for this type, abstracting away any container type.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_CLASS">
				>
			>
			["type_name"] = <
				name = <"type_name">
				documentation = <"Formal string form of the type as per UML.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["has_subtypes"] = <
				name = <"has_subtypes">
				documentation = <"Determine if there are any type substitutions.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["subtypes"] = <
				name = <"subtypes">
				documentation = <"List of type substitutions if any available for this type within the current BMM model.">
				is_abstract = <True>
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["flattened_type_list"] = <
				name = <"flattened_type_list">
				documentation = <"Completely flattened list of type names, flattening out all generic parameters.">
				is_abstract = <True>
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["type_signature"] = <
				name = <"type_signature">
				documentation = <"Signature form of the type, which for generics includes generic parameter constrainer types E.g. `Interval<T:Ordered>`.

Generally useful for display purposes.
">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["is_primitive"] = <
				name = <"is_primitive">
				documentation = <"True if `_base_class.is_primitive_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post_validity"] = <"Result = base_class.is_primitive">
				>
			>
			["entity_metatype"] = <
				name = <"entity_metatype">
				documentation = <"Meta-type of type is by default assumed to be the meta-type of its `_base_class_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
	>
	["BMM_CLASS"] = <
		name = <"BMM_CLASS">
		documentation = <"Meta-type defining a class definition in an object model.">
		ancestors = <"BMM_ENTITY", "BMM_MODEL_ELEMENT">
		is_abstract = <True>
		properties = <
			["name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"name">
				documentation = <"Name of this class. Note that unlike UML, names of classes are just the root name, even if the class is generic. Use `_type_name()_` to obtain the full type name.">
				is_mandatory = <True>
				type = <"String">
			>
			["ancestors"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"ancestors">
				documentation = <"List of immediate inheritance parents.">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["package"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"package">
				documentation = <"Package this class belongs to.">
				is_mandatory = <True>
				type = <"BMM_PACKAGE">
			>
			["properties"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"properties">
				documentation = <"List of attributes defined in this class.">
				type_def = <
					generic_parameters = <"String", "BMM_PROPERTY">
					root_type = <"Hash">
				>
			>
			["source_schema_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"source_schema_id">
				documentation = <"Reference to original source schema defining this class. Useful for UI tools to determine which original schema file to open for a given class for manual editing.">
				is_mandatory = <True>
				type = <"String">
			>
			["immediate_descendants"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"immediate_descendants">
				documentation = <"List of references to base classes of immediate inheritance descendants.">
				type_def = <
					container_type = <"List">
					type = <"BMM_CLASS">
				>
				cardinality = <|>=0|>
			>
			["is_override"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_override">
				documentation = <"True if this definition overrides a class of the same name in an included schema.">
				is_mandatory = <True>
				type = <"Boolean">
			>
		>
		functions = <
			["all_ancestors"] = <
				name = <"all_ancestors">
				documentation = <"List of all inheritance parent class names, recursively.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				is_nullable = <True>
			>
			["all_descendants"] = <
				name = <"all_descendants">
				documentation = <"Compute all descendants by following `_immediate_descendants_`.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				is_nullable = <True>
			>
			["suppliers"] = <
				name = <"suppliers">
				documentation = <"List of names of immediate supplier classes, including concrete generic parameters, concrete descendants of abstract statically defined types, and inherited suppliers. (Where generics are unconstrained, no class name is added, since logically it would be `Any` and this can always be assumed anyway). This list includes primitive types.
">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				is_nullable = <True>
			>
			["suppliers_non_primitive"] = <
				name = <"suppliers_non_primitive">
				documentation = <"Same as `suppliers` minus primitive types, as defined in input schema.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				is_nullable = <True>
			>
			["supplier_closure"] = <
				name = <"supplier_closure">
				documentation = <"List of names of all classes in full supplier closure, including concrete generic parameters; (where generics are unconstrained, no class name is added, since logically it would be `Any` and this can always be assumed anyway).  This list includes primitive types.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				is_nullable = <True>
			>
			["package_path"] = <
				name = <"package_path">
				documentation = <"Fully qualified package name, of form: `package.package`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["class_path"] = <
				name = <"class_path">
				documentation = <"Fully qualified class name, of form: `package.package.CLASS` with package path in lower-case and class in original case.
">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["flat_properties"] = <
				name = <"flat_properties">
				documentation = <"List of all properties due to current and ancestor classes, keyed by property name.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type_def = (P_BMM_GENERIC_TYPE) <
						generic_parameter_defs = <
							["K"] = (P_BMM_SIMPLE_TYPE) <
								type = <"String">
							>
							["V"] = (P_BMM_GENERIC_TYPE) <
								generic_parameters = <"BMM_TYPE", ...>
								root_type = <"BMM_PROPERTY">
							>
						>
						root_type = <"Hash">
					>
				>
				is_nullable = <True>
			>
			["is_primitive"] = <
				name = <"is_primitive">
				documentation = <"True if this class is designated a primitive type within the overall type system of the schema. Set from schema.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_abstract"] = <
				name = <"is_abstract">
				documentation = <"True if this class is abstract in its model. Value provided from an underlying data property set at creation or construction time.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["type"] = <
				name = <"type">
				documentation = <"Generate a type object that represents the type of this class.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_DEFINED_TYPE">
				>
			>
		>
	>
	["BMM_PROPERTY"] = <
		name = <"BMM_PROPERTY">
		documentation = <"Model of a property definition within a class definition of an object model. The generic parameter accommodates the possible meta-type variant descendants of `BMM_TYPE`.">
		ancestors = <"BMM_MODEL_ELEMENT", ...>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"BMM_TYPE">
			>
		>
		properties = <
			["name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"name">
				documentation = <"Name of this property in the model.">
				is_mandatory = <True>
				type = <"String">
			>
			["is_mandatory"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_mandatory">
				documentation = <"True if this property is mandatory in its class.">
				type = <"Boolean">
			>
			["is_computed"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_computed">
				documentation = <"True if this property is computed rather than stored in objects of this class.">
				type = <"Boolean">
			>
			["type"] = (P_BMM_SINGLE_PROPERTY_OPEN) <
				name = <"type">
				documentation = <"Formal type of this property.">
				is_mandatory = <True>
				type = <"T">
			>
			["is_im_runtime"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_im_runtime">
				documentation = <"True if this property is marked with info model `_im_runtime_` property.">
				type = <"Boolean">
				default = <False>
			>
			["is_im_infrastructure"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_im_infrastructure">
				documentation = <"True if this property was marked with info model `_im_infrastructure_` flag.">
				type = <"Boolean">
				default = <False>
			>
			["is_synthesised_generic"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_synthesised_generic">
				documentation = <"True if this property was synthesised due to generic substitution in an inherited type, or further constraining of a formal generic parameter.">
				type = <"Boolean">
				default = <False>
			>
		>
		functions = <
			["existence"] = <
				name = <"existence">
				documentation = <"Interval form of `0..1`, `1..1` etc, derived from `_is_mandatory_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Multiplicity_interval">
				>
			>
			["display_name"] = <
				name = <"display_name">
				documentation = <"Name of this property to display in UI.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
	>
	["BMM_CONTAINER_TYPE"] = <
		name = <"BMM_CONTAINER_TYPE">
		documentation = <"Type that specifies linear containers with a generic parameter corresponding to the type of contained item, and whose container type is a generic type such as `List<T>`, `Set<T>` etc.">
		ancestors = <"BMM_TYPE", ...>
		properties = <
			["container_class"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"container_class">
				documentation = <"The type of the container. This converts to the `_root_type_` in `BMM_GENERIC_TYPE`.">
				is_mandatory = <True>
				type = <"BMM_GENERIC_CLASS">
			>
			["base_type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"base_type">
				documentation = <"The target type; this converts to the first parameter in `_generic_parameters_` in `BMM_GENERIC_TYPE`.">
				is_mandatory = <True>
				type = <"BMM_UNITARY_TYPE">
			>
		>
		functions = <
			["type_name"] = <
				name = <"type_name">
				documentation = <"Return full type name, e.g. `List<ELEMENT>`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["effective_base_class"] = <
				name = <"effective_base_class">
				documentation = <"Result is `_base_class_` of `_base_type_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_CLASS">
				>
				post_conditions = <
					["Post_validity"] = <"Result = base_type.base_class">
				>
			>
			["is_abstract"] = <
				name = <"is_abstract">
				documentation = <"True if `_base_type.is_abstract_` or `_container_type.is_abstract_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["entity_metatype"] = <
				name = <"entity_metatype">
				documentation = <"Meta-type of container type is `Classifier_metatype_container`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["flattened_type_list"] = <
				name = <"flattened_type_list">
				documentation = <"Completely flattened list of type names, flattening out all generic parameters.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["subtypes"] = <
				name = <"subtypes">
				documentation = <"Result is all permutations of current container type and its descendants with the current `_base_type_` and its descendants.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["has_subtypes"] = <
				name = <"has_subtypes">
				documentation = <"Determine if there are any type substitutions.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
	>
	["BMM_GENERIC_TYPE"] = <
		name = <"BMM_GENERIC_TYPE">
		documentation = <"Type reference based on a generic class, e.g. `HashTable <List <Packet>, String>`.">
		ancestors = <"BMM_DEFINED_TYPE", ...>
		properties = <
			["generic_parameters"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"generic_parameters">
				documentation = <"Generic parameters of the `_root_type_` in this type specifier. The order must match the order of the owning class's formal generic parameter declarations.">
				is_mandatory = <True>
				type_def = <
					container_type = <"List">
					type = <"BMM_UNITARY_TYPE">
				>
				cardinality = <|>=1|>
			>
			["base_class"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"base_class">
				documentation = <"The target type; this converts to the first parameter in `_generic_parameters_` in `BMM_GENERIC_TYPE`.">
				is_mandatory = <True>
				type = <"BMM_GENERIC_CLASS">
			>
		>
		functions = <
			["type_name"] = <
				name = <"type_name">
				documentation = <"Return the full name of the type including generic parameters, e.g. `DV_INTERVAL<T>`, `TABLE<List<THING>,String>`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["type_signature"] = <
				name = <"type_signature">
				documentation = <"Signature form of the type, which for generics includes generic parameter constrainer types E.g. `Interval<T:Ordered>`.
">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["is_abstract"] = <
				name = <"is_abstract">
				documentation = <"True if `_base_class.is_abstract_` or if any (non-open) parameter type is abstract.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["flattened_type_list"] = <
				name = <"flattened_type_list">
				documentation = <"Result is `_base_class.name_` followed by names of all generic parameter type names, which may be open or closed.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["subtypes"] = <
				name = <"subtypes">
				documentation = <"Result is the permutation of the base class type and type substitutions of all generic parameters.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["has_subtypes"] = <
				name = <"has_subtypes">
				documentation = <"True if `_base_class.has_descendants_` or any generic parameter type `_type_substitutions_` is True. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_partially_closed"] = <
				name = <"is_partially_closed">
				documentation = <"Returns True if there is any substituted generic parameter.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["effective_base_class"] = <
				name = <"effective_base_class">
				documentation = <"Effective underlying class for this type, abstracting away any container type.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_GENERIC_CLASS">
				>
			>
		>
	>
	["BMM_SIMPLE_TYPE"] = <
		name = <"BMM_SIMPLE_TYPE">
		documentation = <"Type reference to a single type i.e. not generic or container type.">
		ancestors = <"BMM_DEFINED_TYPE", ...>
		functions = <
			["type_name"] = <
				name = <"type_name">
				documentation = <"Result is `_base_class.name_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["is_abstract"] = <
				name = <"is_abstract">
				documentation = <"Result is `_base_class.is_abstract_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["flattened_type_list"] = <
				name = <"flattened_type_list">
				documentation = <"Result is `_base_class.name_` .">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["subtypes"] = <
				name = <"subtypes">
				documentation = <"Result is `_base_class.all_descendants_` .">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["has_subtypes"] = <
				name = <"has_subtypes">
				documentation = <"True if `_base_class.has_descendants_` .">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["effective_base_class"] = <
				name = <"effective_base_class">
				documentation = <"Main design class for this type, from which properties etc can be extracted.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_SIMPLE_CLASS">
				>
			>
		>
	>
	["BMM_ENUMERATION"] = <
		name = <"BMM_ENUMERATION">
		documentation = <"Definition of an enumeration type. In the BMM system, an 'enumeration' type is understood as an underlying basic type and a set of named constants of that type. It is designed so that the default type is Integer, and the default constants are numbered 0, 1, ... Optional model elements can be specified to override the values and / or the type.">
		ancestors = <"BMM_SIMPLE_CLASS", ...>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Ordered">
			>
		>
		properties = <
			["item_names"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"item_names">
				documentation = <"The list of names of the enumeration. If no values are supplied, the integer values 0, 1, 2, ... are assumed.">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["item_values"] = (P_BMM_SINGLE_PROPERTY_OPEN) <
				name = <"item_values">
				documentation = <"Optional list of specific values. Must be 1:1 with `_item_names_` list.">
				type = <"T">
			>
		>
		constants = <
			["underlying_type_name"] = <
				name = <"underlying_type_name">
				documentation = <"Name of type any concrete `BMM_ENUMERATION_*` sub-type is based on, i.e. the name of type bound to 'T' in a declared use of this type.">
				type = <"String">
			>
		>
		functions = <
			["entity_metatype"] = <
				name = <"entity_metatype">
				documentation = <"Meta-type of `BMM_ENUMERATION`, which is `Entity_metatype_enumeration`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["name_map"] = <
				name = <"name_map">
				documentation = <"Map of `_item_values_` (stringified) to `_item_names_`.">
				result = (P_BMM_GENERIC_TYPE) <
					generic_parameters = <"String,String", ...>
					root_type = <"Hash">
				>
			>
		>
	>
	["BMM_ENUMERATION_STRING"] = <
		name = <"BMM_ENUMERATION_STRING">
		documentation = <"String-based enumeration type.">
		ancestors = <"BMM_ENUMERATION", ...>
		constants = <
			["underlying_type_name"] = <
				name = <"underlying_type_name">
				documentation = <"Name of type any concrete `BMM_ENUMERATION_*` sub-type is based on.">
				type = <"String">
				value = <"\"STRING\"">
			>
		>
	>
	["BMM_ENUMERATION_INTEGER"] = <
		name = <"BMM_ENUMERATION_INTEGER">
		documentation = <"Integer-based enumeration type.">
		ancestors = <"BMM_ENUMERATION", ...>
		constants = <
			["underlying_type_name"] = <
				name = <"underlying_type_name">
				documentation = <"Name of type any concrete `BMM_ENUMERATION_*` sub-type is based on.">
				type = <"String">
				value = <"\"INTEGER\"">
			>
		>
	>
	["BMM_PACKAGE"] = <
		name = <"BMM_PACKAGE">
		documentation = <"Abstraction of a package as a tree structure whose nodes can contain other packages and classes.">
		ancestors = <"BMM_PACKAGE_CONTAINER", ...>
		properties = <
			["name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"name">
				documentation = <"Name of this package. This name may be qualified if it is a top-level package.">
				is_mandatory = <True>
				type = <"String">
			>
			["classes"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"classes">
				documentation = <"Classes listed as being in this package.">
				type_def = <
					container_type = <"List">
					type = <"BMM_CLASS">
				>
				cardinality = <|>=0|>
			>
		>
		functions = <
			["root_classes"] = <
				name = <"root_classes">
				documentation = <"Obtain the set of top-level classes in this package, either from this package itself or by recursing into the structure until classes are obtained from child packages. Recurse into each child only far enough to find the first level of classes.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"BMM_CLASS">
				>
				is_nullable = <True>
			>
			["path"] = <
				name = <"path">
				documentation = <"Full path of this package back to root package.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
	>
	["BMM_PARAMETER_TYPE"] = <
		name = <"BMM_PARAMETER_TYPE">
		documentation = <"Definition of a generic parameter in a class definition of a generic type.">
		ancestors = <"BMM_UNITARY_TYPE", ...>
		properties = <
			["name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"name">
				documentation = <"Name of the parameter, e.g. 'T' etc. The name is limited to 1 character and upper-case.">
				is_mandatory = <True>
				type = <"String">
			>
			["type_constraint"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_constraint">
				documentation = <"Optional conformance constraint that must be another valid class name.">
				type = <"BMM_DEFINED_TYPE">
			>
			["inheritance_precursor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"inheritance_precursor">
				documentation = <"If set, is the corresponding generic parameter definition in an ancestor class.">
				type = <"BMM_PARAMETER_TYPE">
			>
		>
		functions = <
			["flattened_conforms_to_type"] = <
				name = <"flattened_conforms_to_type">
				documentation = <"Result is either `_conforms_to_type_` or `_inheritance_precursor.flattened_conforms_to_type_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["effective_conforms_to_type"] = <
				name = <"effective_conforms_to_type">
				documentation = <"Generate ultimate conformance type, which is either `_flattened_conforms_to_type_` or if not set, `Any`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_CLASS">
				>
			>
			["type_signature"] = <
				name = <"type_signature">
				documentation = <"Signature form of the open type, including constrainer type if there is one, e.g. `T:Ordered`.
">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["is_primitive"] = <
				name = <"is_primitive">
				documentation = <"Result = `False` - generic parameters are understood by definition to be non-primitive.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post_validity"] = <"Result = base_class.is_primitive">
				>
			>
			["is_abstract"] = <
				name = <"is_abstract">
				documentation = <"Result = `False` - generic parameters are understood by definition to be non-abstract.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["entity_metatype"] = <
				name = <"entity_metatype">
				documentation = <"Meta-type of a container type is `Entity_metatype_generic_parameter`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["effective_base_class"] = <
				name = <"effective_base_class">
				documentation = <"The effective conformance type of this parameter, or the 'Any' class if none.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_CLASS">
				>
			>
			["has_subtypes"] = <
				name = <"has_subtypes">
				documentation = <"True if `_effective_conforms_to_type.base_class.has_descendants_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["subtypes"] = <
				name = <"subtypes">
				documentation = <"Result is `_effective_conforms_to_type.base_class.all_descendants_` .">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["type_name"] = <
				name = <"type_name">
				documentation = <"Result is `_name_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["flattened_type_list"] = <
				name = <"flattened_type_list">
				documentation = <"Result is either `_flattened_conforms_to_type.flattened_type_list_` or the `Any` type.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
		>
		invariants = <
			["Inv_generic_name"] = <"name.count = 1 and name.is_upper">
		>
	>
	["BMM_ENTITY"] = <
		name = <"BMM_ENTITY">
		documentation = <"Abstract parent of type and class meta-types.">
		ancestors = <"BMM_DEFINITIONS", ...>
		is_abstract = <True>
		constants = <
			["Entity_metatype_simple"] = <
				name = <"Entity_metatype_simple">
				documentation = <"Category of a simple entity, other than enumerated types.">
				type = <"String">
				value = <"\"simple_entity\"">
			>
			["Entity_metatype_enumeration"] = <
				name = <"Entity_metatype_enumeration">
				documentation = <"Category of any enumeration entity.">
				type = <"String">
				value = <"\"enumeration_entity\"">
			>
			["Entity_metatype_generic"] = <
				name = <"Entity_metatype_generic">
				documentation = <"Category of any generic entity that is not a container entity.">
				type = <"String">
				value = <"\"generic_entity\"">
			>
			["Entity_metatype_parameter"] = <
				name = <"Entity_metatype_parameter">
				documentation = <"Category of a formal generic parameter entity.">
				type = <"String">
				value = <"\"generic_parameter_entity\"">
			>
			["Entity_metatype_container"] = <
				name = <"Entity_metatype_container">
				documentation = <"Category of any container entity.">
				type = <"String">
				value = <"\"container_entity\"">
			>
			["Entity_category_modifier_abstract"] = <
				name = <"Entity_category_modifier_abstract">
				documentation = <"Category modifier indicating an entity is formally defined as abstract, i.e. not-directly instantiable within a BMM model.">
				type = <"String">
				value = <"\"abstract\"">
			>
			["Entity_category_modifier_primitive"] = <
				name = <"Entity_category_modifier_primitive">
				documentation = <"Category modifier indicating that an entity is considered to be primitive within the type system of a given BMM model. Has no semantic consequences within the BMM.">
				type = <"String">
				value = <"\"primitive\"">
			>
		>
		functions = <
			["entity_category"] = <
				name = <"entity_category">
				documentation = <"Generate a category code-string to use in visualisation, that indicates:

* _entity meta-type_: simple | enumerated | generic | generic_effective | parameter
* _abstract modifier_ - abstract status
* _primitive modifier_ primitive status

The code is structured as:

----
entity_metatype [ '-' abstract_modifier ] [ '-' primitive_modifier ]
----

">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["entity_metatype"] = <
				name = <"entity_metatype">
				documentation = <"Meta-type of entity, which classifies it according to the kind of formal entity it represents from the following:

* simple (non-generic)
* generic
* enumeration
* type parameter
* container type

These meta-types don't exactly match the `BMM_*` types defined in the model, but are useful for displaying models visually.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["is_abstract"] = <
				name = <"is_abstract">
				documentation = <"If true, indicates an abstract class in a BMM model, or a type based on an abstract class, i.e. a type that cannot be directly instantiated.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_primitive"] = <
				name = <"is_primitive">
				documentation = <"If True, indicates that the entity in a BMM model is considered to relate to a primitive type set, i.e. be a primitive type, or be a definer of one.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
	>
	["BMM_CONTAINER_PROPERTY"] = <
		name = <"BMM_CONTAINER_PROPERTY">
		documentation = <"Subtype of `BMM_PROPERTY` that represents a container type based on one of the inbuilt types `List<T>`, `Set<T>`, `Array<T>`.">
		ancestors = <"BMM_PROPERTY", ...>
		properties = <
			["type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type">
				is_mandatory = <True>
				type = <"BMM_CONTAINER_TYPE">
			>
			["cardinality"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"cardinality">
				documentation = <"Cardinality of this container.">
				type = <"Multiplicity_interval">
			>
		>
		functions = <
			["display_name"] = <
				name = <"display_name">
				documentation = <"Name of this property in form `name: ContainerTypeName<>`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
	>
	["BMM_MODEL"] = <
		name = <"BMM_MODEL">
		documentation = <"Definition of the root of a BMM model (along with what is inherited from `BMM_SCHEMA_CORE`).">
		ancestors = <"BMM_PACKAGE_CONTAINER", "BMM_MODEL_METADATA">
		properties = <
			["class_definitions"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"class_definitions">
				documentation = <"All classes in this schema, keyed by type name.">
				type_def = <
					generic_parameters = <"String", "BMM_CLASS">
					root_type = <"Hash">
				>
			>
			["model_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"model_name">
				documentation = <"Name of this model.">
				is_mandatory = <True>
				type = <"String">
			>
		>
		functions = <
			["model_id"] = <
				name = <"model_id">
				documentation = <"Identifier of this model, lower-case, formed from:

`rm_publisher '_' model_name '_' rm_release`

E.g. `'openehr_ehr_1.0.4'`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["class_definition"] = <
				name = <"class_definition">
				documentation = <"Retrieve the class definition corresponding to `_a_type_name_` (which may contain a generic part).">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_CLASS">
				>
				parameters = <
					["a_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_name">
						type = <"String">
					>
				>
			>
			["type_definition"] = <
				name = <"type_definition">
				documentation = <"Retrieve the class definition corresponding to `_a_type_name_`. If it contains a generic part, this will be removed if it is a fully open generic name, otherwise it will remain intact, i.e. if it is an effective generic name that identifies a `BMM_GENERIC_CLASS_EFFECTIVE`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_CLASS">
				>
			>
			["has_class_definition"] = <
				name = <"has_class_definition">
				documentation = <"True if `_a_class_name_` has a class definition in the model.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_class_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_class_name">
						type = <"String">
					>
				>
			>
			["has_type_definition"] = <
				name = <"has_type_definition">
				documentation = <"True if `_a_type_name_` is already concretely known in the system, including if it is generic, which may be open, partially open or closed.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_type_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_type_name">
						type = <"String">
					>
				>
			>
			["enumeration_definition"] = <
				name = <"enumeration_definition">
				documentation = <"Retrieve the enumeration definition corresponding to `_a_type_name_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_ENUMERATION">
				>
				parameters = <
					["a_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_name">
						type = <"String">
					>
				>
			>
			["primitive_types"] = <
				name = <"primitive_types">
				documentation = <"List of keys in `_class_definitions_` of items marked as primitive types.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				is_nullable = <True>
			>
			["enumeration_types"] = <
				name = <"enumeration_types">
				documentation = <"List of keys in `_class_definitions_` of items that are enumeration types.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				is_nullable = <True>
			>
			["property_definition"] = <
				name = <"property_definition">
				documentation = <"Retrieve the property definition for `_a_prop_name_` in flattened class corresponding to `_a_type_name_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_PROPERTY">
				>
			>
			["ms_conformant_property_type"] = <
				name = <"ms_conformant_property_type">
				documentation = <"True if `_a_ms_property_type_` is a valid 'MS' dynamic type for `_a_property_` in BMM type `_a_bmm_type_name_`. 'MS' conformance means 'model-semantic' conformance, which abstracts away container types like `List<>`, `Set<>` etc and compares the dynamic type with the relation target type in the UML sense, i.e. regardless of whether there is single or multiple containment.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_bmm_type_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_bmm_type_name">
						type = <"String">
					>
					["a_bmm_property_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_bmm_property_name">
						type = <"String">
					>
					["a_ms_property_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_ms_property_name">
						type = <"String">
					>
				>
			>
			["property_definition_at_path"] = <
				name = <"property_definition_at_path">
				documentation = <"Retrieve the property definition for `_a_property_path_` in flattened class corresponding to `_a_type_name_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_PROPERTY">
				>
			>
			["class_definition_at_path"] = <
				name = <"class_definition_at_path">
				documentation = <"Retrieve the class definition for the class that owns the terminal attribute in `a_prop_path` in flattened class corresponding to `a_type_name`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_CLASS">
				>
				parameters = <
					["a_type_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_type_name">
						type = <"String">
					>
					["a_prop_path"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_prop_path">
						type = <"String">
					>
				>
			>
			["all_ancestor_classes"] = <
				name = <"all_ancestor_classes">
				documentation = <"Return all ancestor types of `_a_class_name_` up to root class (usually `Any`, `Object` or something similar). Does  not include current class. Returns empty list if none.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				parameters = <
					["a_class"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_class">
						type = <"String">
					>
				>
				is_nullable = <True>
			>
			["is_descendant_of"] = <
				name = <"is_descendant_of">
				documentation = <"True if `_a_class_name_` is a descendant in the model of `_a_parent_class_name_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_class_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_class_name">
						type = <"String">
					>
					["a_parent_class_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_parent_class_name">
						type = <"String">
					>
				>
			>
			["type_conforms_to"] = <
				name = <"type_conforms_to">
				documentation = <"Check conformance of `_a_desc_type_` to `_an_anc_type_`; the types may be generic, and may contain open generic parameters like 'T' etc. These are replaced with their appropriate constrainer types, or Any during the conformance testing process.

Conformance is found if:

* [base class test] types are non-generic, and either type names are identical, or else `_a_desc_type_` has `_an_anc_type_` in its ancestors;
* both types are generic and pass base class test; number of generic params matches, and each generic parameter type, after 'open parameter' substitution, recursively passes; `_type_name_conforms_to_` test
* descendant type is generic and ancestor type is not, and they pass base classes test.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_desc_type"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_desc_type">
						type = <"String">
					>
					["an_anc_type"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"an_anc_type">
						type = <"String">
					>
				>
			>
			["any_class_definition"] = <
				name = <"any_class_definition">
				documentation = <"`BMM_CLASS` instance for the `Any` class. This may be defined in the BMM schema, but if not, a default `Any` class will be generated.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_SIMPLE_CLASS">
				>
			>
			["any_type_definition"] = <
				name = <"any_type_definition">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_SIMPLE_TYPE">
				>
			>
		>
	>
	["BMM_PACKAGE_CONTAINER"] = <
		name = <"BMM_PACKAGE_CONTAINER">
		documentation = <"A BMM model component that contains packages and classes.">
		ancestors = <"BMM_MODEL_ELEMENT", ...>
		properties = <
			["packages"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"packages">
				documentation = <"Child packages; keys all in upper case for guaranteed matching.">
				type_def = <
					generic_parameters = <"String", "BMM_PACKAGE">
					root_type = <"Hash">
				>
			>
		>
		functions = <
			["package_at_path"] = <
				name = <"package_at_path">
				documentation = <"Package at the path `_a_path_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_PACKAGE">
				>
				parameters = <
					["a_path"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_path">
						type = <"String">
					>
				>
				is_nullable = <True>
			>
			["do_recursive_packages"] = <
				name = <"do_recursive_packages">
				documentation = <"Recursively execute `_action_`, which is a procedure taking a `BMM_PACKAGE` argument, on all members of packages.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["action"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"action">
						type = <"PROCEDURE">
					>
				>
			>
			["has_package_path"] = <
				name = <"has_package_path">
				documentation = <"True if there is a package at the path `_a_path_`; paths are delimited with delimiter `_Package_name_delimiter_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_path"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_path">
						type = <"String">
					>
				>
			>
		>
	>
	["BMM_GENERIC_CLASS"] = <
		name = <"BMM_GENERIC_CLASS">
		documentation = <"Definition of a generic class in an object model.">
		ancestors = <"BMM_CLASS", ...>
		properties = <
			["generic_parameters"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"generic_parameters">
				documentation = <"List of generic parameter definitions, keyed by name of generic parameter; these are defined either directly on this class or by the addition of an ancestor class which is generic.">
				is_mandatory = <True>
				type_def = <
					generic_parameters = <"String", "BMM_PARAMETER_TYPE">
					root_type = <"Hash">
				>
			>
		>
		functions = <
			["suppliers"] = <
				name = <"suppliers">
				documentation = <"Add suppliers from generic parameters.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				is_nullable = <True>
			>
			["entity_metatype"] = <
				name = <"entity_metatype">
				documentation = <"Meta-type of `BMM_GENERIC_CLASS`, which is `Entity_metatype_generic`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["type"] = <
				name = <"type">
				documentation = <"Generate a fully open `BMM_GENERIC_TYPE` instance that corresponds to this class definition">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_GENERIC_TYPE">
				>
			>
			["generic_parameter_conformance_type"] = <
				name = <"generic_parameter_conformance_type">
				documentation = <"For a generic class, type to which generic parameter `a_name` conforms e.g. if this class is `Interval <T:Comparable>` then the Result will be the single type `Comparable`. For an unconstrained type `T`, the Result will be `Any`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
				parameters = <
					["a_name"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_name">
						type = <"String">
					>
				>
			>
		>
	>
	["BMM_DEFINITIONS"] = <
		name = <"BMM_DEFINITIONS">
		documentation = <"Definitions used by all BMM packages.">
		constants = <
			["Bmm_internal_version"] = <
				name = <"Bmm_internal_version">
				documentation = <"Current internal version of BMM meta-model, used to determine if a given schema can be processed by a given implementation of the model.">
				type = <"String">
			>
			["Schema_name_delimiter"] = <
				name = <"Schema_name_delimiter">
				documentation = <"Delimiter used to separate schema id from package path in a fully qualified path.">
				type = <"String">
				value = <"\"::\"">
			>
			["Package_name_delimiter"] = <
				name = <"Package_name_delimiter">
				documentation = <"Delimiter used to separate package names in a package path.">
				type = <"String">
				value = <"\".\"">
			>
			["Bmm_schema_file_extension"] = <
				name = <"Bmm_schema_file_extension">
				documentation = <"Extension used for BMM files.">
				type = <"String">
				value = <"\".bmm\"">
			>
		>
	>
	["BMM_MODEL_ELEMENT"] = <
		name = <"BMM_MODEL_ELEMENT">
		documentation = <"Ancestor class of most BMM model elements.">
		ancestors = <"BMM_DEFINITIONS", ...>
		is_abstract = <True>
		properties = <
			["documentation"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"documentation">
				documentation = <"Optional documentation of this element.">
				type = <"String">
			>
		>
	>
	["BMM_UNITARY_TYPE"] = <
		name = <"BMM_UNITARY_TYPE">
		documentation = <"Parent of meta-types that may be used as the type of any instantiated object that is not a container object.">
		ancestors = <"BMM_TYPE", ...>
		is_abstract = <True>
	>
	["BMM_INDEXED_CONTAINER_TYPE"] = <
		name = <"BMM_INDEXED_CONTAINER_TYPE">
		documentation = <"Type of linear container that indexes the contained items in the manner of a standard Hash table, map or dictionary.">
		ancestors = <"BMM_CONTAINER_TYPE", ...>
		properties = <
			["index_type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"index_type">
				documentation = <"Type of the element index, typically `String` or `Integer`, but may be a numeric type or indeed any type from which a hash value can be derived.">
				is_mandatory = <True>
				type = <"BMM_SIMPLE_TYPE">
			>
		>
	>
	["BMM_DEFINED_TYPE"] = <
		name = <"BMM_DEFINED_TYPE">
		ancestors = <"BMM_UNITARY_TYPE", ...>
		is_abstract = <True>
		properties = <
			["base_class"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"base_class">
				documentation = <"The target type; this converts to the first parameter in `_generic_parameters_` in `BMM_GENERIC_TYPE`.">
				is_mandatory = <True>
				type = <"BMM_CLASS">
			>
		>
	>
	["BMM_SIMPLE_CLASS"] = <
		name = <"BMM_SIMPLE_CLASS">
		documentation = <"Definition of a simple class, i.e. a class that has no generic parameters and is 1:1 with the type it generates.">
		ancestors = <"BMM_CLASS", ...>
		functions = <
			["type"] = <
				name = <"type">
				documentation = <"Generate a type object that represents the type of this class. Can only be an instance of `BMM_SIMPLE_TYPE` or a descendant.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"BMM_SIMPLE_TYPE">
				>
			>
			["entity_metatype"] = <
				name = <"entity_metatype">
				documentation = <"Meta-type of `BMM_SIMPLE_CLASS`, which is `Entity_metatype_simple`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
	>
	["BMM_MODEL_METADATA"] = <
		name = <"BMM_MODEL_METADATA">
		documentation = <"Core properties of `BMM_MODEL`, may be used in a serial representation as well, such as `P_BMM_SCHEMA`.">
		properties = <
			["rm_publisher"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_publisher">
				documentation = <"Publisher of model expressed in the schema.">
				is_mandatory = <True>
				type = <"String">
			>
			["rm_release"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_release">
				documentation = <"Release of model expressed in the schema as a 3-part numeric, e.g. \"3.1.0\" . ">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["EXPR_TYPE_DEF"] = <
		name = <"EXPR_TYPE_DEF">
		documentation = <"Ancestor class for type definitions known in the openEHR Expression formalism.">
		is_abstract = <True>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				documentation = <"Natural language type name of this type as used in abstract rules syntax variable declarations.">
				is_mandatory = <True>
				type = <"String">
			>
			["type_anchor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_anchor">
				documentation = <"Attribute of the openEHR primitive type (or Any) corresponding to this type definition meta-type.">
				is_mandatory = <True>
				type = <"Any">
			>
		>
	>
	["TYPE_DEF_BOOLEAN"] = <
		name = <"TYPE_DEF_BOOLEAN">
		documentation = <"Rules meta-type representing the primitive type Boolean.">
		ancestors = <"EXPR_TYPE_DEF", ...>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				is_mandatory = <True>
				type = <"String">
				default = <"\"Boolean\"">
			>
			["type_anchor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_anchor">
				is_mandatory = <True>
				type = <"Boolean">
			>
		>
	>
	["TYPE_DEF_DATE"] = <
		name = <"TYPE_DEF_DATE">
		documentation = <"Rules meta-type representing the primitive type Date.">
		ancestors = <"EXPR_TYPE_DEF", ...>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				is_mandatory = <True>
				type = <"String">
				default = <"\"Date\"">
			>
			["type_anchor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_anchor">
				is_mandatory = <True>
				type = <"IDate">
			>
		>
	>
	["TYPE_DEF_DATE_TIME"] = <
		name = <"TYPE_DEF_DATE_TIME">
		documentation = <"Rules meta-type representing the primitive type Date_time.">
		ancestors = <"EXPR_TYPE_DEF", ...>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				is_mandatory = <True>
				type = <"String">
				default = <"\"Date_time\"">
			>
			["type_anchor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_anchor">
				is_mandatory = <True>
				type = <"IDate_time">
			>
		>
	>
	["TYPE_DEF_DURATION"] = <
		name = <"TYPE_DEF_DURATION">
		documentation = <"Rules meta-type representing the primitive type Duration.">
		ancestors = <"EXPR_TYPE_DEF", ...>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				is_mandatory = <True>
				type = <"String">
				default = <"\"Duration\"">
			>
			["type_anchor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_anchor">
				is_mandatory = <True>
				type = <"IDuration">
			>
		>
	>
	["TYPE_DEF_INTEGER"] = <
		name = <"TYPE_DEF_INTEGER">
		documentation = <"Rules meta-type representing the primitive type Integer.">
		ancestors = <"EXPR_TYPE_DEF", ...>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				is_mandatory = <True>
				type = <"String">
				default = <"\"Integer\"">
			>
			["type_anchor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_anchor">
				is_mandatory = <True>
				type = <"Integer">
			>
		>
	>
	["TYPE_DEF_OBJECT_REF"] = <
		name = <"TYPE_DEF_OBJECT_REF">
		documentation = <"Rules meta-type representing the type Object_ref, which is assumed to by the type of any non-primitive reference target within a rule.">
		ancestors = <"EXPR_TYPE_DEF", ...>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				is_mandatory = <True>
				type = <"String">
				default = <"\"Object_ref\"">
			>
		>
	>
	["TYPE_DEF_REAL"] = <
		name = <"TYPE_DEF_REAL">
		documentation = <"Rules meta-type representing the primitive type Real.">
		ancestors = <"EXPR_TYPE_DEF", ...>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				is_mandatory = <True>
				type = <"String">
				default = <"\"Real\"">
			>
			["type_anchor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_anchor">
				is_mandatory = <True>
				type = <"Real">
			>
		>
	>
	["TYPE_DEF_STRING"] = <
		name = <"TYPE_DEF_STRING">
		documentation = <"Rules meta-type representing the primitive type String.">
		ancestors = <"EXPR_TYPE_DEF", ...>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				is_mandatory = <True>
				type = <"String">
				default = <"\"String\"">
			>
			["type_anchor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_anchor">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["TYPE_DEF_TERMINOLOGY_CODE"] = <
		name = <"TYPE_DEF_TERMINOLOGY_CODE">
		documentation = <"Rules meta-type representing the primitive type Terminology_code.">
		ancestors = <"EXPR_TYPE_DEF", ...>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				is_mandatory = <True>
				type = <"String">
				default = <"\"Terminology_code\"">
			>
			["type_anchor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_anchor">
				is_mandatory = <True>
				type = <"Terminology_code">
			>
		>
	>
	["TYPE_DEF_TIME"] = <
		name = <"TYPE_DEF_TIME">
		documentation = <"Rules meta-type representing the primitive type Time.">
		ancestors = <"EXPR_TYPE_DEF", ...>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				is_mandatory = <True>
				type = <"String">
				default = <"\"Time\"">
			>
			["type_anchor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_anchor">
				is_mandatory = <True>
				type = <"ITime">
			>
		>
	>
	["TYPE_DEF_URI"] = <
		name = <"TYPE_DEF_URI">
		documentation = <"Rules meta-type representing the primitive type Uri.">
		ancestors = <"EXPR_TYPE_DEF", ...>
		properties = <
			["type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_name">
				is_mandatory = <True>
				type = <"String">
				default = <"\"Uri\"">
			>
			["type_anchor"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_anchor">
				is_mandatory = <True>
				type = <"Integer">
			>
		>
	>
	["ASSERTION"] = <
		name = <"ASSERTION">
		documentation = <"Meta-type for a first order predicate logic expression with a Boolean result. ">
		ancestors = <"STATEMENT", ...>
		properties = <
			["tag"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"tag">
				documentation = <"Expression tag, used for differentiating multiple assertions.">
				type = <"String">
			>
			["string_expression"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"string_expression">
				documentation = <"String form of expression, in case an expression evaluator taking String expressions is used for evaluation. ">
				type = <"String">
			>
			["expression"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"expression">
				documentation = <"Root of expression tree.">
				is_mandatory = <True>
				type = <"EXPRESSION">
			>
		>
	>
	["ASSIGNMENT"] = <
		name = <"ASSIGNMENT">
		documentation = <"Meta-type representing the assignment statement, which associates a named variable with an expression, and produces no value.">
		ancestors = <"STATEMENT", ...>
		properties = <
			["target"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"target">
				documentation = <"The target variable on the notional left-hand side of this assignment.">
				is_mandatory = <True>
				type = <"VARIABLE_DECLARATION">
			>
			["source"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"source">
				documentation = <"Source right hand side) of the assignment.">
				is_mandatory = <True>
				type = <"EXPR_VALUE">
			>
		>
	>
	["EXPR_BINARY_OPERATOR"] = <
		name = <"EXPR_BINARY_OPERATOR">
		documentation = <"Binary operator expression node.">
		ancestors = <"EXPR_OPERATOR", ...>
		properties = <
			["left_operand"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"left_operand">
				documentation = <"Left operand node.">
				is_mandatory = <True>
				type = <"EXPRESSION">
			>
			["right_operand"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"right_operand">
				documentation = <"Right operand node.">
				is_mandatory = <True>
				type = <"EXPRESSION">
			>
		>
	>
	["EXPR_FUNCTION_CALL"] = <
		name = <"EXPR_FUNCTION_CALL">
		documentation = <"Node representing a function call with 0 or more arguments.">
		ancestors = <"EXPR_LEAF", ...>
		properties = <
			["arguments"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"arguments">
				documentation = <"Arguments of this function, which can be from 0 to any number. Functions with no arguments are typically used to represent real world varying values like 'current time' and so on.">
				type_def = <
					container_type = <"List">
					type = <"EXPRESSION">
				>
				cardinality = <|>=0|>
			>
		>
	>
	["EXPRESSION"] = <
		name = <"EXPRESSION">
		documentation = <"Abstract parent of all expression meta-types.">
		ancestors = <"EXPR_VALUE", ...>
		is_abstract = <True>
		functions = <
			["type"] = <
				name = <"type">
				documentation = <"The primitive type of this node, which must be determined by redefinitions in concrete classes.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"EXPR_TYPE_DEF">
				>
			>
		>
	>
	["EXPR_LEAF"] = <
		name = <"EXPR_LEAF">
		documentation = <"Meta-type representing one of:

* a manifest constant of any primitive type;
* a path referring to a value in the archetype;
* a constraint;
* a variable reference.
">
		ancestors = <"EXPRESSION", ...>
		is_abstract = <True>
		properties = <
			["item"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"item">
				documentation = <"The reference item from which the value of this node can be computed.">
				type = <"Any">
			>
		>
	>
	["EXPR_LITERAL"] = <
		name = <"EXPR_LITERAL">
		documentation = <"Literal value expression tree leaf item. This can represent a literal value of any primitive type included in the `PRIMITIVE_TYPE` enumeration.">
		ancestors = <"EXPR_LEAF", ...>
		properties = <
			["item"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"item">
				documentation = <"A statically set constant value of a primitive type.">
				is_mandatory = <True>
				type = <"Any">
			>
		>
	>
	["EXPR_OPERATOR"] = <
		name = <"EXPR_OPERATOR">
		documentation = <"Abstract parent of operator types.">
		ancestors = <"EXPRESSION", ...>
		is_abstract = <True>
		properties = <
			["precedence_overridden"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"precedence_overridden">
				documentation = <"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.">
				type = <"Boolean">
			>
			["operator_def"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"operator_def">
				documentation = <"Operator definition.">
				is_mandatory = <True>
				type = <"OPERATOR_DEF">
			>
			["symbol"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"symbol">
				documentation = <"The symbol actually used in the rule, or intended to be used for serialisation. Must be a member of `operator_def.symbols`.">
				type = <"String">
			>
		>
		invariants = <
			["Symbol_validity"] = <"symbol /= Void implies operator_def.symbols.has (symbol)">
		>
	>
	["EXPR_UNARY_OPERATOR"] = <
		name = <"EXPR_UNARY_OPERATOR">
		documentation = <"Unary operator expression node.">
		ancestors = <"EXPR_OPERATOR", ...>
		properties = <
			["operand"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"operand">
				documentation = <"Operand node.">
				is_mandatory = <True>
				type = <"EXPRESSION">
			>
		>
	>
	["EXPR_VARIABLE_REF"] = <
		name = <"EXPR_VARIABLE_REF">
		documentation = <"Expression tree leaf item representing a reference to a declared variable.">
		ancestors = <"EXPR_LEAF", ...>
		properties = <
			["item"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"item">
				documentation = <"The variable referred to.">
				is_mandatory = <True>
				type = <"VARIABLE_DECLARATION">
			>
		>
	>
	["EXTERNAL_QUERY"] = <
		name = <"EXTERNAL_QUERY">
		documentation = <"Definition of a variable whose value is derived from a query run on a data context in the operational environment. Typical uses of this kind of variable are to obtain values like the patient date of birth, sex, weight, and so on. It could also be used to obtain items from a knowledge context, such as a drug database.">
		ancestors = <"EXPR_VALUE", ...>
		properties = <
			["context"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"context">
				documentation = <"Optional name of context. This allows a basic separation of query types to be done in more sophisticated environments. Possible values might be “patient”, “medications” and so on.
Not yet standardised.
">
				is_mandatory = <True>
				type = <"String">
			>
			["query_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"query_id">
				documentation = <"Identifier of query in the external context, e.g. “date_of_birth”.
Not yet standardised.
">
				is_mandatory = <True>
				type = <"String">
			>
			["query_args"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"query_args">
				documentation = <"Optional arguments to query.
Not yet standardised.
">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
		>
	>
	["EXPR_VALUE"] = <
		name = <"EXPR_VALUE">
		documentation = <"Any kind of statement element that can be evaluated. The type will either be supplied in descendant types or else will be inferred by an assignment statement linked to a typed variable.">
		is_abstract = <True>
		functions = <
			["value"] = <
				name = <"value">
				documentation = <"The computed value of this node as a result of the nodes below it, for operator nodes, or else statically set or otherwise derived values.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Any">
				>
			>
		>
	>
	["STATEMENT_SET"] = <
		name = <"STATEMENT_SET">
		documentation = <"A container for a specific set of statements intended to be used together.">
		properties = <
			["statement"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"statement">
				documentation = <"The member statements of this statement set.">
				type_def = <
					container_type = <"List">
					type = <"STATEMENT">
				>
				cardinality = <|>=0|>
			>
			["name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"name">
				documentation = <"Optional name of this rule set.">
				type = <"String">
			>
		>
		functions = <
			["execution_result"] = <
				name = <"execution_result">
				documentation = <"Execution result of the whole rule set. Determined by the and-ing of result values of Assertions in the rule set.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
	>
	["STATEMENT"] = <
		name = <"STATEMENT">
		documentation = <"Meta-type for the notion of statement, which is a non-value-returning entity.">
		is_abstract = <True>
	>
	["VARIABLE_DECLARATION"] = <
		name = <"VARIABLE_DECLARATION">
		documentation = <"Meta-type for the declaration of a named variable that can be used in an expression.">
		ancestors = <"STATEMENT", ...>
		properties = <
			["name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"name">
				documentation = <"Name of the variable.">
				is_mandatory = <True>
				type = <"String">
			>
			["type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type">
				documentation = <"Primitive type of the variable, enabling its use to be type-checked in expressions.">
				is_mandatory = <True>
				type = <"EXPR_TYPE_DEF">
			>
		>
	>
	["OPERATOR_DEF"] = <
		name = <"OPERATOR_DEF">
		documentation = <"Abstract definition of an operator for use in the Rules evaluator.">
		properties = <
			["identifier"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"identifier">
				documentation = <"Unique identifier of this operator within the rules system.">
				is_mandatory = <True>
				type = <"String">
			>
			["symbols"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"symbols">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
		>
	>
	["EXPR_VALUE_REF"] = <
		name = <"EXPR_VALUE_REF">
		documentation = <"Path-based reference to a value in a data structure.">
		ancestors = <"EXPR_LEAF", ...>
	>
	["EXPR_FOR_ALL"] = <
		name = <"EXPR_FOR_ALL">
		documentation = <"Universal quantification operator, usually known as `for_all`, whose operand is a collection of items referenced by an `EXPR_VALUE_REF`. The `_condition_` attribute represents an assertion that is applied to every member of the collection at runtime to determine the result.">
		ancestors = <"EXPR_OPERATOR", ...>
		properties = <
			["condition"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"condition">
				documentation = <"Boolean condition that returns True or False when applied to a member of the operand of a `for_all` operator.">
				is_mandatory = <True>
				type = <"ASSERTION">
			>
			["operand"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"operand">
				documentation = <"Reference to collection / container object to which the `for_all` operator is to be applied.">
				is_mandatory = <True>
				type = <"EXPR_VALUE_REF">
			>
		>
	>
	["IDate"] = <
		name = <"IDate">
		documentation = <"Interface of an absolute point in time, as measured on the Gregorian calendar, and specified only to the day.">
		ancestors = <"Temporal", ...>
		is_abstract = <True>
		functions = <
			["year"] = <
				name = <"year">
				documentation = <"Year.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["month"] = <
				name = <"month">
				documentation = <"Month in year.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
				pre_conditions = <
					["Pre"] = <"not month_unknown">
				>
			>
			["day"] = <
				name = <"day">
				documentation = <"Day in month.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
				pre_conditions = <
					["Pre"] = <"not day_unknown">
				>
			>
			["timezone"] = <
				name = <"timezone">
				documentation = <"Timezone; may be Void.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"ITimezone">
				>
			>
			["as_string"] = <
				name = <"as_string">
				documentation = <"ISO8601 string for date/time, in format `YYYYMMDDThhmmss[,sss][Z | ±hh[mm]]` or in extended format `YYYY-MM-DDThh:mm:ss[,sss][Z | ±hh[mm]]` or a partial variant; see valid_iso8601_date_time() below.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
		invariants = <
			["Day_valid"] = <"valid_day(year, month, day)">
			["Month_valid"] = <"valid_month (month)">
		>
	>
	["IDate_time"] = <
		name = <"IDate_time">
		documentation = <"Defines the interface of an absolute point in time, specified to fractional seconds.">
		ancestors = <"Temporal", ...>
		is_abstract = <True>
		functions = <
			["year"] = <
				name = <"year">
				documentation = <"Year.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["month"] = <
				name = <"month">
				documentation = <"Month in year.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
				pre_conditions = <
					["Pre"] = <"not month_unknown">
				>
			>
			["day"] = <
				name = <"day">
				documentation = <"Day in month.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
				pre_conditions = <
					["Pre"] = <"not day_unknown">
				>
			>
			["hour"] = <
				name = <"hour">
				documentation = <"Hour in day.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
				pre_conditions = <
					["Pre"] = <"not hour_unknown">
				>
			>
			["minute"] = <
				name = <"minute">
				documentation = <"Minute in hour.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
				pre_conditions = <
					["Pre"] = <"not minute_unknown">
				>
			>
			["second"] = <
				name = <"second">
				documentation = <"Second in minute.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
				pre_conditions = <
					["Pre"] = <"not second_unknown">
				>
			>
			["fractional_second"] = <
				name = <"fractional_second">
				documentation = <"Fractional seconds.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Real">
				>
			>
			["timezone"] = <
				name = <"timezone">
				documentation = <"Timezone; may be Void.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"ITimezone">
				>
			>
		>
		invariants = <
			["Year_valid"] = <"valid_year (year)">
			["Month_valid"] = <"valid_month (month)">
			["Day_valid"] = <"valid_day(year, month, day)">
			["Hour_valid"] = <"valid_hour (hour, minute, second)">
		>
	>
	["IDuration"] = <
		name = <"IDuration">
		documentation = <"Defines the interface of a period of time corresponding to a difference between two timepoints.">
		ancestors = <"Temporal", ...>
		is_abstract = <True>
		functions = <
			["seconds"] = <
				name = <"seconds">
				documentation = <"Number of seconds.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["fractional_seconds"] = <
				name = <"fractional_seconds">
				documentation = <"Fractional seconds.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Real">
				>
			>
		>
		invariants = <
			["Years_valid"] = <"years >= 0">
			["Months_valid"] = <"months >= 0">
			["Weeks_valid"] = <"weeks >= 0">
			["Days_valid"] = <"days >= 0">
			["Hours_valid"] = <"hours >= 0">
			["Minutes_valid"] = <"minutes >= 0">
			["Seconds_valid"] = <"seconds >= 0">
			["Fractional_second_valid"] = <"fractional_second >= 0.0 and fractional_second < 1.0">
		>
	>
	["ITimezone"] = <
		name = <"ITimezone">
		documentation = <"Interface definition of a timezone.">
		ancestors = <"Temporal", ...>
		is_abstract = <True>
		functions = <
			["hour"] = <
				name = <"hour">
				documentation = <"Hour part of timezone - in the range 00 - 13.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["minute"] = <
				name = <"minute">
				documentation = <"Minute part of timezone. Generally 00 or 30.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["sign"] = <
				name = <"sign">
				documentation = <"Direction of timezone expresssed as +1 or -1.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
		>
		invariants = <
			["Min_hour_valid"] = <"sign = -1 implies hour > 0 and hour <= Min_timezone_hour">
			["Max_hour_valid"] = <"sign = 1 implies hour > 0 and hour <= Max_timezone_hour">
			["Minute_valid"] = <"not minute_unknown implies valid_minute (minute)">
			["Sign_valid"] = <"sign = 1 or sign = -1">
		>
	>
	["ITime"] = <
		name = <"ITime">
		documentation = <"Defines the interface of an absolute point in time from an origin usually interpreted as meaning the start of the current day, specified to fractional seconds.">
		ancestors = <"Temporal", ...>
		is_abstract = <True>
		functions = <
			["hour"] = <
				name = <"hour">
				documentation = <"Hour in day, in 24-hour time.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["minute"] = <
				name = <"minute">
				documentation = <"Minute in hour.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["second"] = <
				name = <"second">
				documentation = <"Second in minute.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["fractional_second"] = <
				name = <"fractional_second">
				documentation = <"Fractional seconds.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Real">
				>
				pre_conditions = <
					["Pre"] = <"not second_unknown">
				>
			>
			["timezone"] = <
				name = <"timezone">
				documentation = <"Timezone; may be Void.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"ITimezone">
				>
				is_nullable = <True>
			>
		>
		invariants = <
			["Hour_valid"] = <"valid_hour(hour, minute, second)">
		>
	>
	["Time_Definitions"] = <
		name = <"Time_Definitions">
		documentation = <"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.">
		constants = <
			["Seconds_in_minute"] = <
				name = <"Seconds_in_minute">
				type = <"Integer">
				value = <60>
			>
			["Minutes_in_hour"] = <
				name = <"Minutes_in_hour">
				type = <"Integer">
				value = <60>
			>
			["Hours_in_day"] = <
				name = <"Hours_in_day">
				type = <"Integer">
				value = <24>
			>
			["Nominal_days_in_month"] = <
				name = <"Nominal_days_in_month">
				documentation = <"Used for conversions of durations containing months to days and / or seconds.">
				type = <"Real">
				value = <30.42>
			>
			["Max_days_in_month"] = <
				name = <"Max_days_in_month">
				type = <"Integer">
				value = <31>
			>
			["Days_in_year"] = <
				name = <"Days_in_year">
				type = <"Integer">
				value = <365>
			>
			["Days_in_leap_year"] = <
				name = <"Days_in_leap_year">
				type = <"Integer">
				value = <366>
			>
			["Max_days_in_year"] = <
				name = <"Max_days_in_year">
				type = <"Integer">
				value = <"Days_in_leap_year">
			>
			["Nominal_days_in_year"] = <
				name = <"Nominal_days_in_year">
				documentation = <"Used for conversions of durations containing years to days and / or seconds.">
				type = <"Real">
				value = <365.24>
			>
			["Days_in_week"] = <
				name = <"Days_in_week">
				type = <"Integer">
				value = <7>
			>
			["Months_in_year"] = <
				name = <"Months_in_year">
				type = <"Integer">
				value = <12>
			>
			["Min_timezone_hour"] = <
				name = <"Min_timezone_hour">
				documentation = <"Minimum hour value of a timezone (note that the -ve sign is supplied in the ISO8601_TIMEZONE class).">
				type = <"Integer">
				value = <12>
			>
			["Max_timezone_hour"] = <
				name = <"Max_timezone_hour">
				type = <"Integer">
				value = <13>
			>
		>
		functions = <
			["valid_year"] = <
				name = <"valid_year">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["y"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"y">
						type = <"Integer">
					>
				>
				post_conditions = <
					["Post"] = <"Result = y >= 0">
				>
			>
			["valid_month"] = <
				name = <"valid_month">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["m"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"m">
						type = <"Integer">
					>
				>
				post_conditions = <
					["Post"] = <"Result = m >= 1 and m <= Months_in_year">
				>
			>
			["valid_day"] = <
				name = <"valid_day">
				documentation = <"True if d >= 1 and d <= days_in_month (m, y)">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["y"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"y">
						type = <"Integer">
					>
					["m"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"m">
						type = <"Integer">
					>
					["d"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"d">
						type = <"Integer">
					>
				>
				post_conditions = <
					["Post"] = <"Result = d >= 1 and d <= days_in_month (m, y)">
				>
			>
			["valid_hour"] = <
				name = <"valid_hour">
				documentation = <"True if (h >= 0 and h < Hours_in_day) or (h = Hours_in_day and m = 0 and s = 0)">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["h"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"h">
						type = <"Integer">
					>
					["m"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"m">
						type = <"Integer">
					>
					["s"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"s">
						type = <"Integer">
					>
				>
				post_conditions = <
					["Post"] = <"Result = (h >= 0 and h < Hours_in_day) or (h = Hours_in_day and m = 0 and s = 0)">
				>
			>
			["valid_minute"] = <
				name = <"valid_minute">
				documentation = <"True if m >= 0 and m < Minutes_in_hour.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["m"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"m">
						type = <"Integer">
					>
				>
				post_conditions = <
					["Post"] = <"Result = m >= 0 and m < Minutes_in_hour">
				>
			>
			["valid_second"] = <
				name = <"valid_second">
				documentation = <"True if s >= 0 and s < Seconds_in_minute .">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["s"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"s">
						type = <"Integer">
					>
				>
				post_conditions = <
					["Post"] = <"Result = s >= 0 and s < Seconds_in_minute">
				>
			>
			["valid_fractional_second"] = <
				name = <"valid_fractional_second">
				documentation = <"True if fs >= 0.0 and fs < 1.0 .">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["fs"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"fs">
						type = <"Double">
					>
				>
				post_conditions = <
					["Post"] = <"Result = fs >= 0.0 and fs < 1.0 .">
				>
			>
		>
	>
	["Timezone"] = <
		name = <"Timezone">
		documentation = <"Assumed built-in primitive type representing a timezone.">
		ancestors = <"ITimezone", ...>
	>
	["Aggregate"] = <
		name = <"Aggregate">
		documentation = <"Abstract ancestor of container types whose items are addressable in some way.">
		ancestors = <"Any", ...>
		is_abstract = <True>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Any">
			>
		>
		functions = <
			["has"] = <
				name = <"has">
				documentation = <"Test for membership of a value.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["v"] = (P_BMM_SINGLE_FUNCTION_PARAMETER_OPEN) <
						name = <"v">
						type = <"T">
					>
				>
			>
			["count"] = <
				name = <"count">
				documentation = <"Number of items in container.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["is_empty"] = <
				name = <"is_empty">
				documentation = <"True if container is empty.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
	>
	["Comparable"] = <
		name = <"Comparable">
		is_abstract = <True>
	>
	["TUPLE"] = <
		name = <"TUPLE">
		documentation = <"Parent type of all TUPLE types.">
	>
	["FUNCTION"] = <
		name = <"FUNCTION">
		documentation = <"Type representing a function with a return type and 0 or more arguments represented as a TUPLE.">
		ancestors = <"ROUTINE", ...>
		generic_parameter_defs = <
			["ARGS"] = <
				name = <"ARGS">
				conforms_to_type = <"TUPLE">
			>
			["RESULT"] = <
				name = <"RESULT">
				conforms_to_type = <"Any">
			>
		>
	>
	["TUPLE1"] = <
		name = <"TUPLE1">
		documentation = <"A Tuple type used, among other things, for representing a single typed argument within a Routine signature.">
		ancestors = <"TUPLE", ...>
		generic_parameter_defs = <
			["A"] = <
				name = <"A">
				conforms_to_type = <"Any">
			>
		>
	>
	["TUPLE2"] = <
		name = <"TUPLE2">
		documentation = <"A Tuple type used, among other things, for representing two typed arguments within a Routine signature.">
		ancestors = <"TUPLE", ...>
		generic_parameter_defs = <
			["A"] = <
				name = <"A">
				conforms_to_type = <"Any">
			>
			["B"] = <
				name = <"B">
				conforms_to_type = <"Any">
			>
		>
	>
	["ROUTINE"] = <
		name = <"ROUTINE">
		documentation = <"Type representing a function with a return type and 0 or more arguments represented as a TUPLE.">
		generic_parameter_defs = <
			["ARGS"] = <
				name = <"ARGS">
				conforms_to_type = <"TUPLE">
			>
		>
	>
	["PROCEDURE"] = <
		name = <"PROCEDURE">
		documentation = <"Type representing a procedure with 0 or more arguments represented as a TUPLE.">
		ancestors = <"ROUTINE", ...>
		generic_parameter_defs = <
			["ARGS"] = <
				name = <"ARGS">
				conforms_to_type = <"TUPLE">
			>
		>
	>
	["Iso8601_timezone"] = <
		name = <"Iso8601_timezone">
		documentation = <"Represents a timezone as used in ISO 8601.">
		ancestors = <"Iso8601_type", "ITimezone">
		functions = <
			["minute_unknown"] = <
				name = <"minute_unknown">
				documentation = <"Indicates whether minute part known.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_partial"] = <
				name = <"is_partial">
				documentation = <"True if this time zone is partial, i.e. if minutes is missing.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_extended"] = <
				name = <"is_extended">
				documentation = <"True if this time-zone uses ‘:’ separators.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["as_string"] = <
				name = <"as_string">
				documentation = <"ISO8601 timezone string, in format:

* `Z | ±hh[mm]`

where:

* `hh` is \"00\" - \"23\" (0-filled to two digits)
* `mm` is \"00\" - \"59\" (0-filled to two digits)
* `Z` is a literal meaning UTC (modern replacement for GMT), i.e. timezone `+0000`">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["is_gmt"] = <
				name = <"is_gmt">
				documentation = <"True if timezone is UTC, i.e. +0000.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["as_timezone"] = <
				name = <"as_timezone">
				documentation = <"Convert to a native `Timezone`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Timezone">
				>
			>
		>
		invariants = <
			["Min_hour_valid"] = <"sign = -1 implies hour > 0 and hour <= Min_timezone_hour">
			["Max_hour_valid"] = <"sign = 1 implies hour > 0 and hour <= Max_timezone_hour">
			["Minute_valid"] = <"not minute_unknown implies valid_minute (minute)">
			["Sign_valid"] = <"sign = 1 or sign = -1">
		>
	>
	["Proper_interval"] = <
		name = <"Proper_interval">
		documentation = <"Type representing a 'proper' Interval, i.e. any two-sided or one-sided interval.">
		ancestors = <"Interval", ...>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Ordered">
			>
		>
		properties = <
			["upper"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"upper">
				documentation = <"Upper bound.">
				type = <"T">
			>
		>
	>
	["Point_interval"] = <
		name = <"Point_interval">
		documentation = <"Type representing an Interval that happens to be a point value. Provides an efficient representation that is substitutable for Interval<T> where needed.">
		ancestors = <"Interval", ...>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Ordered">
			>
		>
		properties = <
			["lower_unbounded"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"lower_unbounded">
				documentation = <"lower boundary open (i.e. = -infinity)">
				is_mandatory = <True>
				type = <"Boolean">
				default = <False>
			>
			["upper_unbounded"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"upper_unbounded">
				documentation = <"upper boundary open (i.e. = +infinity)">
				is_mandatory = <True>
				type = <"Boolean">
				default = <False>
			>
			["lower_included"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"lower_included">
				documentation = <"lower boundary value included in range if not lower_unbounded.">
				is_mandatory = <True>
				type = <"Boolean">
				default = <True>
			>
			["upper_included"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"upper_included">
				documentation = <"upper boundary value included in range if not upper_unbounded.">
				is_mandatory = <True>
				type = <"Boolean">
				default = <True>
			>
		>
		functions = <
			["upper"] = <
				name = <"upper">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"T">
				>
				is_nullable = <True>
			>
		>
	>
	["AUTHORED_RESOURCE"] = <
		name = <"AUTHORED_RESOURCE">
		documentation = <"Abstract idea of an online resource created by a human author. 
">
		is_abstract = <True>
		properties = <
			["original_language"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"original_language">
				documentation = <"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. ">
				is_mandatory = <True>
				type = <"Terminology_code">
			>
			["is_controlled"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_controlled">
				documentation = <"True if this resource is under any kind of change control (even file copying), in which case revision history is created. ">
				type = <"Boolean">
			>
			["description"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"description">
				documentation = <"Description and lifecycle information of the resource.">
				type = <"RESOURCE_DESCRIPTION">
			>
			["uid"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"uid">
				documentation = <"Unique identifier of the family of archetypes having the same interface identifier (same major version).">
				type = <"UUID">
			>
			["annotations"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"annotations">
				documentation = <"Annotations on individual items within the resource, keyed by path. The inner table takes the form of a Hash table of String values keyed by String tags.">
				type = <"RESOURCE_ANNOTATIONS">
			>
			["translations"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"translations">
				documentation = <"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.">
				type_def = <
					generic_parameters = <"String", "TRANSLATION_DETAILS">
					root_type = <"Hash">
				>
			>
		>
		functions = <
			["current_revision"] = <
				name = <"current_revision">
				documentation = <"Most recent revision in revision_history if is_controlled else  (uncontrolled) . ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
				post_conditions = <
					["Post"] = <"Result = revision_history.most_recent_version">
				>
			>
			["languages_available"] = <
				name = <"languages_available">
				documentation = <"Total list of languages available in this resource, derived from original_language and translations. ">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
		>
		invariants = <
			["Original_language_valid"] = <"code_set (Code_set_id_languages).has_code (original_language.as_string)">
			["Current_revision_valid"] = <"(current_revision /= Void and not is_controlled) implies current_revision.is_equal (\"(uncontrolled)\")">
			["Translations_valid"] = <"translations /= Void implies (not translations.is_empty and not translations.has (orginal_language.code_string))">
			["Description_valid"] = <"translations /= Void implies (description.details.for_all (d &#124;
translations.has_key (d.language.code_string)))">
			["Languages_available_valid"] = <"languages_available.has (original_language)">
			["Revision_history_valid"] = <"is_controlled xor revision_history = Void">
		>
	>
	["RESOURCE_DESCRIPTION"] = <
		name = <"RESOURCE_DESCRIPTION">
		documentation = <"Defines the descriptive meta-data of a resource.">
		properties = <
			["original_author"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"original_author">
				documentation = <"Original author of this resource, with all relevant details, including organisation.">
				is_mandatory = <True>
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
			["original_namespace"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"original_namespace">
				documentation = <"Namespace of original author's organisation, in reverse internet form, if applicable.">
				type = <"String">
			>
			["original_publisher"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"original_publisher">
				documentation = <"Plain text name of organisation that originally published this artefact, if any.">
				type = <"String">
			>
			["other_contributors"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"other_contributors">
				documentation = <"Other contributors to the resource, each listed in \"name <email>\"  form. ">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["lifecycle_state"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"lifecycle_state">
				documentation = <"Lifecycle state of the resource, typically including states such as: initial, in_development, in_review, published, superseded, obsolete. ">
				is_mandatory = <True>
				type = <"Terminology_code">
			>
			["parent_resource"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"parent_resource">
				documentation = <"Reference to owning resource. ">
				is_mandatory = <True>
				type = <"AUTHORED_RESOURCE">
				default = <"">
			>
			["custodian_namespace"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"custodian_namespace">
				documentation = <"Namespace in reverse internet id form, of current custodian organisation.">
				type = <"String">
			>
			["custodian_organisation"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"custodian_organisation">
				documentation = <"Plain text name of current custodian organisation.">
				type = <"String">
			>
			["copyright"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"copyright">
				documentation = <"Optional copyright statement for the resource as a knowledge resource. 
">
				type = <"String">
			>
			["licence"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"licence">
				documentation = <"Licence of current artefact, in format \"short licence name <URL of licence>\", e.g. \"Apache 2.0 License <http://www.apache.org/licenses/LICENSE-2.0.html>\"">
				type = <"String">
			>
			["ip_acknowledgements"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"ip_acknowledgements">
				documentation = <"List of acknowledgements of other IP directly referenced in this archetype, typically terminology codes, ontology ids etc. Recommended keys are the widely known name or namespace for the IP source, as shown in the following example:

----
ip_acknowledgements = <
    [\"loinc\"] = <\"This content from LOINC® is copyright © 1995 Regenstrief Institute, Inc. and the LOINC Committee, and available at no cost under the license at http://loinc.org/terms-of-use\">
    [\"snomedct\"] = <\"Content from SNOMED CT® is copyright © 2007 IHTSDO <ihtsdo.org>\">
>
----">
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
			["references"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"references">
				documentation = <"List of references of material on which this artefact is based, as a keyed list of strings. The keys should be in a standard citation format.">
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
			["resource_package_uri"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"resource_package_uri">
				documentation = <"URI of package to which this resource belongs.">
				type = <"String">
			>
			["conversion_details"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"conversion_details">
				documentation = <"Details related to conversion process that generated this model from an original, if relevant, as a list of name/value pairs. Typical example with recommended tags:

----
conversion_details = <
    [\"source_model\"] = <\"CEM model xyz <http://location.in.clinicalelementmodels.com>\">
    [\"tool\"] = <\"cem2adl v6.3.0\">
    [\"time\"] = <\"2014-11-03T09:05:00\">
>
----">
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
			["other_details"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"other_details">
				documentation = <"Additional non language-sensitive resource meta-data, as a list of name/value pairs.">
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
			["details"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"details">
				documentation = <"Details of all parts of resource description that are natural language-dependent, keyed by language code.">
				type_def = <
					generic_parameters = <"String", "RESOURCE_DESCRIPTION_ITEM">
					root_type = <"Hash">
				>
			>
		>
	>
	["TRANSLATION_DETAILS"] = <
		name = <"TRANSLATION_DETAILS">
		documentation = <"Class providing details of a natural language translation. ">
		properties = <
			["language"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"language">
				documentation = <"Language of the translation, coded using ISO 639-1 (2 character) language codes.">
				is_mandatory = <True>
				type = <"Terminology_code">
			>
			["author"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"author">
				documentation = <"Translator name and other demographic details.">
				is_mandatory = <True>
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
			["accreditaton"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"accreditaton">
				documentation = <"Accreditation of translator, usually a national translator's registration or association membership id.">
				type = <"String">
			>
			["other_details"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"other_details">
				documentation = <"Any other meta-data.">
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
			["version_last_translated"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"version_last_translated">
				documentation = <"Version of this resource last time it was translated into the language represented by this TRANSLATION_DETAILS object.">
				type = <"String">
			>
		>
	>
	["RESOURCE_DESCRIPTION_ITEM"] = <
		name = <"RESOURCE_DESCRIPTION_ITEM">
		documentation = <"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.">
		properties = <
			["language"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"language">
				documentation = <"The localised language in which the items in this description item are written. Coded using ISO 639-1 (2 character) language codes.">
				is_mandatory = <True>
				type = <"Terminology_code">
			>
			["purpose"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"purpose">
				documentation = <"Purpose of the resource.">
				is_mandatory = <True>
				type = <"String">
			>
			["keywords"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"keywords">
				documentation = <"Keywords which characterise this resource, used e.g. for indexing and searching. 
">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["use"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"use">
				documentation = <"Description of the uses of the resource, i.e. contexts in which it could be used. 
">
				type = <"String">
			>
			["misuse"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"misuse">
				documentation = <"Description of any misuses of the resource, i.e. contexts in which it should not be used.">
				type = <"String">
			>
			["original_resource_uri"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"original_resource_uri">
				documentation = <"URIs of original clinical document(s) or description of which resource is a formalisation, in the language of this description item; keyed by meaning.">
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
			["other_details"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"other_details">
				documentation = <"Additional language-sensitive resource metadata, as a list of name/value pairs. ">
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
		>
	>
	["RESOURCE_ANNOTATIONS"] = <
		name = <"RESOURCE_ANNOTATIONS">
		documentation = <"Object representing annotations on an archetype. These can be of various forms, with a documentation form defined so far, which has a multi-level tabular structure [ [ [String value, String key], path key], language key]. Example instance, showing the documentation structure.

--------
    documentation = <
        [\"en\"] = <
           [\"/data[id2]\"] = <
               [\"ui\"] = <\"passthrough\">
           >
           [\"/data[id2]/items[id3]\"] = <
               [\"design note\"] = <\"this is a design note on Statement\">
               [\"requirements note\"] = <\"this is a requirements note on Statement\">
               [\"medline ref\"] = <\"this is a medline ref on Statement\">
           >
        >
    >
--------

Other sub-structures might have different keys, e.g.  based on programming languages, UI toolkits etc.
">
		properties = <
			["documentation"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"documentation">
				documentation = <"Documentary annotations in a multi-level keyed structure.">
				is_mandatory = <True>
				type_def = <
					generic_parameter_defs = <
						["K"] = (P_BMM_SIMPLE_TYPE) <
							type = <"String">
						>
						["V"] = (P_BMM_GENERIC_TYPE) <
							generic_parameter_defs = <
								["K"] = (P_BMM_SIMPLE_TYPE) <
									type = <"String">
								>
								["V"] = (P_BMM_GENERIC_TYPE) <
									generic_parameters = <"String", "String">
									root_type = <"Hash">
								>
							>
							root_type = <"Hash">
						>
					>
					root_type = <"Hash">
				>
			>
		>
	>
	["P_BMM_CLASS"] = <
		name = <"P_BMM_CLASS">
		documentation = <"Definition of persistent form of `BMM_CLASS` for serialisation to ODIN, JSON, XML etc.">
		ancestors = <"P_BMM_MODEL_ELEMENT", ...>
		properties = <
			["name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"name">
				documentation = <"Name of the class. Persisted attribute.">
				is_mandatory = <True>
				type = <"String">
			>
			["ancestors"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"ancestors">
				documentation = <"List of immediate inheritance parents. Persisted attribute.">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["properties"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"properties">
				documentation = <"List of attributes defined in this class. Persistent attribute.">
				type_def = <
					generic_parameters = <"String", "P_BMM_PROPERTY">
					root_type = <"Hash">
				>
			>
			["is_abstract"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_abstract">
				documentation = <"True if this is an abstract type. Persisted attribute.">
				type = <"Boolean">
			>
			["is_override"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_override">
				documentation = <"True if this class definition overrides one found in an included schema.">
				type = <"Boolean">
			>
			["generic_parameter_defs"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"generic_parameter_defs">
				documentation = <"List of generic parameter definitions. Persisted attribute.">
				type_def = <
					generic_parameters = <"String", "P_BMM_GENERIC_PARAMETER">
					root_type = <"Hash">
				>
			>
			["source_schema_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"source_schema_id">
				documentation = <"Reference to original source schema defining this class. Set during `BMM_SCHEMA` materialise. Useful for GUI tools to enable user to edit the schema file containing a given class (i.e. taking into account that a class may be in any of the schemas in a schema inclusion hierarchy).">
				is_mandatory = <True>
				type = <"String">
			>
			["bmm_class"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_class">
				documentation = <"`BMM_CLASS` object built by `_create_bmm_class_definition_` and `_populate_bmm_class_definition_`.">
				type = <"BMM_CLASS">
			>
			["uid"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"uid">
				documentation = <"Unique id generated for later comparison during merging, in order to detect if two classes are the same. Assigned in post-load processing.">
				is_mandatory = <True>
				type = <"Integer">
			>
		>
		functions = <
			["is_generic"] = <
				name = <"is_generic">
				documentation = <"True if this class is a generic class.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result := generic_parameter_defs /= Void">
				>
			>
			["create_bmm_class"] = <
				name = <"create_bmm_class">
				documentation = <"Create `_bmm_class_definition_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
			>
			["populate_bmm_class"] = <
				name = <"populate_bmm_class">
				documentation = <"Add remaining model elements from Current to `_bmm_class_definition_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["a_bmm_schema"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_bmm_schema">
						type = <"BMM_MODEL">
					>
				>
			>
		>
	>
	["P_BMM_ENUMERATION"] = <
		name = <"P_BMM_ENUMERATION">
		documentation = <"Persistent form of `BMM_ENUMERATION` attributes.">
		ancestors = <"P_BMM_CLASS", ...>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
			>
		>
		properties = <
			["item_names"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"item_names">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["item_values"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"item_values">
				type_def = <
					container_type = <"List">
					type = <"Any">
				>
				cardinality = <|>=0|>
			>
			["bmm_class"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_class">
				documentation = <"`BMM_CLASS` object build by `_create_bmm_class_definition_` and `_populate_bmm_class_definition_`.">
				type = <"BMM_ENUMERATION">
			>
		>
	>
	["P_BMM_SCHEMA"] = <
		name = <"P_BMM_SCHEMA">
		documentation = <"Persisted form of `BMM_SCHEMA`.">
		ancestors = <"P_BMM_PACKAGE_CONTAINER", "BMM_SCHEMA">
		properties = <
			["primitive_types"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"primitive_types">
				documentation = <"Primitive type definitions. Persisted attribute.">
				type_def = <
					container_type = <"List">
					type = <"P_BMM_CLASS">
				>
				cardinality = <|>=0|>
			>
			["class_definitions"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"class_definitions">
				documentation = <"Class definitions. Persisted attribute.">
				type_def = <
					container_type = <"List">
					type = <"P_BMM_CLASS">
				>
				cardinality = <|>=0|>
			>
			["includes"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"includes">
				documentation = <"Inclusion list, in the form of a hash of individual include specifications, each of which at least specifies the id of another schema, and may specify a namespace via which types from the included schemas are known in this schema.
Persisted attribute.">
				type_def = <
					generic_parameters = <"String", "BMM_INCLUDE_SPEC">
					root_type = <"Hash">
				>
			>
		>
		functions = <
			["validate_created"] = <
				name = <"validate_created">
				documentation = <"Implementation of `_validate_created()_`">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				pre_conditions = <
					["Pre_state"] = <"state = State_created">
				>
				post_conditions = <
					["Post_state"] = <"passed implies state = State_validated_created">
				>
			>
			["load_finalise"] = <
				name = <"load_finalise">
				documentation = <"Implementation of `_load_finalise()_`">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				pre_conditions = <
					["Pre_state"] = <"state = State_validated_created">
				>
				post_conditions = <
					["Post_state"] = <"state = State_includes_processed or state = State_includes_pending">
				>
			>
			["merge"] = <
				name = <"merge">
				documentation = <"Implementation of `_merge()_`">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"P_BMM_SCHEMA">
					>
				>
				pre_conditions = <
					["Pre_state"] = <"state = State_includes_pending">
					["Pre_other_valid"] = <"includes_to_process.has (included_schema.schema_id)">
				>
			>
			["validate"] = <
				name = <"validate">
				documentation = <"Implementation of `_validate()_`">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
			>
			["create_bmm_model"] = <
				name = <"create_bmm_model">
				documentation = <"Implementation of `_create_bmm_model()_`">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				pre_conditions = <
					["Pre_state"] = <"state = P_BMM_PACKAGE_STATE.State_includes_processed">
				>
			>
			["canonical_packages"] = <
				name = <"canonical_packages">
				documentation = <"Package structure in which all top-level qualified package names like `xx.yy.zz` have been expanded out to a hierarchy of `BMM_PACKAGE` objects.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"P_BMM_PACKAGE">
				>
			>
		>
	>
	["P_BMM_PROPERTY"] = <
		name = <"P_BMM_PROPERTY">
		documentation = <"Persistent form of `BMM_PROPERTY`.">
		ancestors = <"P_BMM_MODEL_ELEMENT", ...>
		is_abstract = <True>
		properties = <
			["name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"name">
				documentation = <"Name of this property within its class. Persisted attribute.">
				is_mandatory = <True>
				type = <"String">
			>
			["is_mandatory"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_mandatory">
				documentation = <"True if this property is mandatory in its class. Persisted attribute.">
				type = <"Boolean">
			>
			["is_computed"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_computed">
				documentation = <"True if this property is computed rather than stored in objects of this class. Persisted Attribute.">
				type = <"Boolean">
			>
			["is_im_infrastructure"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_im_infrastructure">
				documentation = <"True if this property is info model 'infrastructure' rather than 'data'. Persisted attribute.">
				type = <"Boolean">
			>
			["is_im_runtime"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_im_runtime">
				documentation = <"True if this property is info model 'runtime' settable property. Persisted attribute.">
				type = <"Boolean">
			>
			["type_def"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_def">
				documentation = <"Type definition of this property, if not a simple String type reference. Persisted attribute.">
				type = <"P_BMM_TYPE">
			>
			["bmm_property"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"bmm_property">
				documentation = <"BMM_PROPERTY created by create_bmm_property_definition.">
				type_def = <
					generic_parameters = <"BMM_TYPE", ...>
					root_type = <"BMM_PROPERTY">
				>
			>
		>
		functions = <
			["create_bmm_property"] = <
				name = <"create_bmm_property">
				documentation = <"Create `_bmm_property_definition_` from `P_BMM_XX` parts.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["a_bmm_schema"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_bmm_schema">
						type = <"BMM_MODEL">
					>
					["a_class_def"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_class_def">
						type = <"BMM_CLASS">
					>
				>
			>
		>
	>
	["P_BMM_GENERIC_PARAMETER"] = <
		name = <"P_BMM_GENERIC_PARAMETER">
		documentation = <"Persistent form of `BMM_GENERIC_PARAMETER`.">
		ancestors = <"P_BMM_MODEL_ELEMENT", ...>
		properties = <
			["name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"name">
				documentation = <"Name of the parameter, e.g. 'T' etc. Persisted attribute. Name is limited to 1 character, upper case.">
				is_mandatory = <True>
				type = <"String">
			>
			["conforms_to_type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"conforms_to_type">
				documentation = <"Optional conformance constraint - the name of a type to which a concrete substitution of this generic parameter must conform. Persisted attribute.">
				type = <"String">
			>
			["bmm_generic_parameter"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_generic_parameter">
				documentation = <"`BMM_GENERIC_PARAMETER` created by `_create_bmm_generic_parameter_`.">
				type = <"BMM_PARAMETER_TYPE">
			>
		>
		functions = <
			["create_bmm_generic_parameter"] = <
				name = <"create_bmm_generic_parameter">
				documentation = <"Create `_bmm_generic_parameter_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["a_bmm_schema"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_bmm_schema">
						type = <"BMM_MODEL">
					>
				>
			>
		>
		invariants = <
			["Post_name"] = <"name.count = 1 and name.is_upper">
		>
	>
	["P_BMM_TYPE"] = <
		name = <"P_BMM_TYPE">
		documentation = <"Persistent form of `BMM_TYPE`.">
		is_abstract = <True>
		properties = <
			["bmm_type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_type">
				documentation = <"Result of `_create_bmm_type()_` call.">
				type = <"BMM_TYPE">
			>
		>
		functions = <
			["create_bmm_type"] = <
				name = <"create_bmm_type">
				documentation = <"Create appropriate `BMM_XXX` object; effected in descendants.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["a_schema"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_schema">
						type = <"BMM_MODEL">
					>
					["a_class_def"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_class_def">
						type = <"BMM_CLASS">
					>
				>
			>
			["as_type_string"] = <
				name = <"as_type_string">
				documentation = <"Formal name of the type for display.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
	>
	["P_BMM_CONTAINER_TYPE"] = <
		name = <"P_BMM_CONTAINER_TYPE">
		documentation = <"Persistent form of `BMM_CONTAINER_TYPE`.">
		ancestors = <"P_BMM_TYPE", ...>
		properties = <
			["container_type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"container_type">
				documentation = <"The type of the container. This converts to the `_root_type_` in `BMM_GENERIC_TYPE`. Persisted attribute.">
				is_mandatory = <True>
				type = <"String">
			>
			["type_def"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_def">
				documentation = <"Type definition of `_type_`, if not a simple String type reference. Persisted attribute.">
				type = <"P_BMM_BASE_TYPE">
			>
			["type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type">
				documentation = <"The target type; this converts to the first parameter in `_generic_parameters_` in `BMM_GENERIC_TYPE`. Persisted attribute.">
				type = <"String">
			>
			["bmm_type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_type">
				documentation = <"Result of `_create_bmm_type()_` call.">
				type = <"BMM_CONTAINER_TYPE">
			>
		>
		functions = <
			["type_ref"] = <
				name = <"type_ref">
				documentation = <"The target type; this converts to the first parameter in `_generic_parameters_` in `BMM_GENERIC_TYPE`. Persisted attribute.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"P_BMM_BASE_TYPE">
				>
			>
		>
	>
	["P_BMM_SIMPLE_TYPE"] = <
		name = <"P_BMM_SIMPLE_TYPE">
		documentation = <"Persistent form of `BMM_SIMPLE_TYPE`.">
		ancestors = <"P_BMM_BASE_TYPE", ...>
		properties = <
			["type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type">
				documentation = <"Name of type - must be a simple class name.">
				is_mandatory = <True>
				type = <"String">
			>
			["bmm_type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_type">
				documentation = <"Result of `_create_bmm_type()_` call.">
				type = <"BMM_SIMPLE_TYPE">
			>
		>
	>
	["P_BMM_OPEN_TYPE"] = <
		name = <"P_BMM_OPEN_TYPE">
		documentation = <"Persistent form of `BMM_PARAMETER_TYPE`.">
		ancestors = <"P_BMM_BASE_TYPE", ...>
		properties = <
			["type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type">
				documentation = <"Simple type parameter as a single letter like 'T', 'G' etc.">
				is_mandatory = <True>
				type = <"String">
			>
			["bmm_type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_type">
				documentation = <"Result of `_create_bmm_type()_` call.">
				type = <"Any">
			>
		>
	>
	["P_BMM_GENERIC_TYPE"] = <
		name = <"P_BMM_GENERIC_TYPE">
		documentation = <"Persistent form of `BMM_GENERIC_TYPE`.">
		ancestors = <"P_BMM_BASE_TYPE", ...>
		properties = <
			["root_type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"root_type">
				documentation = <"Root type of this generic type, e.g. `Interval` in `Interval<Integer>`.">
				is_mandatory = <True>
				type = <"String">
			>
			["generic_parameter_defs"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"generic_parameter_defs">
				documentation = <"Generic parameters of the root_type in this type specifier if non-simple types. The order must match the order of the owning class's formal generic parameter declarations. Persistent attribute.">
				is_mandatory = <True>
				type_def = <
					container_type = <"List">
					type = <"P_BMM_TYPE">
				>
				cardinality = <|>=1|>
			>
			["generic_parameters"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"generic_parameters">
				documentation = <"Generic parameters of the `_root_type_` in this type specifier, if simple types. The order must match the order of the owning class's formal generic parameter declarations. Persistent attribute.">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["bmm_type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_type">
				documentation = <"Result of `_create_bmm_type()_` call.">
				type = <"BMM_GENERIC_TYPE">
			>
		>
		functions = <
			["generic_parameter_refs"] = <
				name = <"generic_parameter_refs">
				documentation = <"Generic parameters of the root_type in this type specifier. The order must match the order of the owning class's formal generic parameter declarations">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"P_BMM_TYPE">
				>
				is_nullable = <True>
			>
		>
	>
	["P_BMM_PACKAGE"] = <
		name = <"P_BMM_PACKAGE">
		documentation = <"Persisted form of a package as a tree structure whose nodes can contain more packages and/or classes.">
		ancestors = <"P_BMM_PACKAGE_CONTAINER", "P_BMM_MODEL_ELEMENT">
		properties = <
			["name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"name">
				documentation = <"Name of the package from schema; this name may be qualified if it is a top-level package within the schema, or unqualified. Persistent attribute.">
				is_mandatory = <True>
				type = <"String">
			>
			["classes"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"classes">
				documentation = <"List of classes in this package. Persistent attribute.">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["bmm_package_definition"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_package_definition">
				documentation = <"`BMM_PACKAGE` created by `_create_bmm_package_definition_`.">
				type = <"BMM_PACKAGE">
			>
		>
		functions = <
			["merge"] = <
				name = <"merge">
				documentation = <"Merge packages and classes from other (from an included `P_BMM_SCHEMA`) into this package.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"P_BMM_PACKAGE">
					>
				>
			>
			["create_bmm_package_definition"] = <
				name = <"create_bmm_package_definition">
				documentation = <"Generate a `BMM_PACKAGE_DEFINITION` object and write it to `_bmm_package_definition_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
			>
		>
	>
	["P_BMM_PACKAGE_CONTAINER"] = <
		name = <"P_BMM_PACKAGE_CONTAINER">
		documentation = <"Persisted form of a model component that contains packages.">
		properties = <
			["packages"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"packages">
				documentation = <"Package structure as a hierarchy of packages each potentially containing names of classes in that package in the original model.">
				is_mandatory = <True>
				type_def = <
					generic_parameters = <"String", "P_BMM_PACKAGE">
					root_type = <"Hash">
				>
			>
		>
	>
	["P_BMM_CONTAINER_PROPERTY"] = <
		name = <"P_BMM_CONTAINER_PROPERTY">
		documentation = <"Persistent form of `BMM_CONTAINER_PROPERTY`.">
		ancestors = <"P_BMM_PROPERTY", ...>
		properties = <
			["cardinality"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"cardinality">
				documentation = <"Cardinality of this property in its class. Persistent attribute.">
				type_def = <
					generic_parameters = <"Integer", ...>
					root_type = <"Interval">
				>
			>
			["type_def"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_def">
				documentation = <"Type definition of this property, if not a simple String type reference. Persistent attribute.">
				type = <"P_BMM_CONTAINER_TYPE">
			>
			["bmm_property"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_property">
				documentation = <"`BMM_PROPERTY` created by `_create_bmm_property_`.">
				type = <"BMM_CONTAINER_PROPERTY">
			>
		>
		functions = <
			["create_bmm_property"] = <
				name = <"create_bmm_property">
				documentation = <"Create `_bmm_property_definition_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"void">
				>
				parameters = <
					["a_bmm_schema"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_bmm_schema">
						type = <"BMM_MODEL">
					>
					["a_class_def"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_class_def">
						type = <"BMM_CLASS">
					>
				>
			>
		>
	>
	["P_BMM_SINGLE_PROPERTY"] = <
		name = <"P_BMM_SINGLE_PROPERTY">
		documentation = <"Persistent form of `BMM_SINGLE_PROPERTY`.">
		ancestors = <"P_BMM_PROPERTY", ...>
		properties = <
			["type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type">
				documentation = <"If the type is a simple type, then this attribute will hold the type name. If the type is a container or generic, then type_ref will hold the type definition. The resulting type is generated in type_def.">
				type = <"String">
			>
			["type_ref"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_ref">
				documentation = <"Type definition of this property computed from `_type_` for later use in `_bmm_property_`.">
				type = <"P_BMM_SIMPLE_TYPE">
			>
			["bmm_property"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"bmm_property">
				documentation = <"`BMM_PROPERTY` created by `_create_bmm_property_definition_`.">
				type_def = <
					generic_parameters = <"BMM_SIMPLE_TYPE", ...>
					root_type = <"BMM_PROPERTY">
				>
			>
		>
		functions = <
			["type_def"] = <
				name = <"type_def">
				documentation = <"Generate `_type_ref_` from `_type_` and save.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"P_BMM_SIMPLE_TYPE">
				>
			>
		>
	>
	["P_BMM_SINGLE_PROPERTY_OPEN"] = <
		name = <"P_BMM_SINGLE_PROPERTY_OPEN">
		documentation = <"Persistent form of a `BMM_SINGLE_PROPERTY_OPEN`.">
		ancestors = <"P_BMM_PROPERTY", ...>
		properties = <
			["type_ref"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_ref">
				documentation = <"Type definition of this property computed from `_type_` for later use in `_bmm_property_`.">
				type = <"P_BMM_OPEN_TYPE">
			>
			["type"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type">
				documentation = <"Type definition of this property, if a simple String type reference. Really we should use `_type_def_` to be regular in the schema, but that makes the schema more wordy and less clear. So we use this persisted String value, and compute the `_type_def_` on the fly. Persisted attribute.">
				type = <"String">
			>
			["bmm_property"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"bmm_property">
				documentation = <"`BMM_PROPERTY` created by `_create_bmm_property_definition_`.">
				type_def = <
					generic_parameters = <"BMM_OPEN_TYPE", ...>
					root_type = <"BMM_PROPERTY">
				>
			>
		>
		functions = <
			["type_def"] = <
				name = <"type_def">
				documentation = <"Generate `_type_ref_` from `_type_` and save.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"P_BMM_OPEN_TYPE">
				>
			>
		>
	>
	["P_BMM_GENERIC_PROPERTY"] = <
		name = <"P_BMM_GENERIC_PROPERTY">
		documentation = <"Persistent form of `BMM_GENERIC_PROPERTY`.">
		ancestors = <"P_BMM_PROPERTY", ...>
		properties = <
			["type_def"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"type_def">
				documentation = <"Type definition of this property, if not a simple String type reference. Persistent attribute.">
				type = <"P_BMM_GENERIC_TYPE">
			>
			["bmm_property"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"bmm_property">
				documentation = <"`BMM_PROPERTY` created by `_create_bmm_property_definition_`.">
				type_def = <
					generic_parameters = <"BMM_GENERIC_TYPE", ...>
					root_type = <"BMM_PROPERTY">
				>
			>
		>
	>
	["P_BMM_ENUMERATION_INTEGER"] = <
		name = <"P_BMM_ENUMERATION_INTEGER">
		documentation = <"Persistent form of an instance of `BMM_ENUMERATION_INTEGER`.">
		ancestors = <"P_BMM_ENUMERATION", ...>
		properties = <
			["bmm_class"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_class">
				documentation = <"`BMM_CLASS` object build by `_create_bmm_class_definition_` and `_populate_bmm_class_definition_`.">
				type = <"BMM_ENUMERATION_INTEGER">
			>
		>
	>
	["P_BMM_ENUMERATION_STRING"] = <
		name = <"P_BMM_ENUMERATION_STRING">
		documentation = <"Persistent form of `BMM_ENUMERATION_STRING`.">
		ancestors = <"P_BMM_ENUMERATION", ...>
		properties = <
			["bmm_class"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"bmm_class">
				documentation = <"`BMM_CLASS` object build by `_create_bmm_class_definition_` and `_populate_bmm_class_definition_`.">
				type = <"BMM_ENUMERATION_STRING">
			>
		>
	>
	["BMM_INCLUDE_SPEC"] = <
		name = <"BMM_INCLUDE_SPEC">
		documentation = <"Schema inclusion structure.">
		properties = <
			["id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"id">
				documentation = <"Full identifier of the included schema, e.g. \"openehr_primitive_types_1.0.2\".">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["P_BMM_MODEL_ELEMENT"] = <
		name = <"P_BMM_MODEL_ELEMENT">
		documentation = <"Persistent form of `BMM_MODEL_ELEMENT`.">
		is_abstract = <True>
		properties = <
			["documentation"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"documentation">
				documentation = <"Optional documentation of this element.">
				type = <"String">
			>
		>
	>
	["P_BMM_BASE_TYPE"] = <
		name = <"P_BMM_BASE_TYPE">
		documentation = <"Persistent form of `BMM_PROPER_TYPE`.">
		ancestors = <"P_BMM_TYPE", ...>
		is_abstract = <True>
	>
	["BMM_SCHEMA_STATE"] = (P_BMM_ENUMERATION_STRING) <
		name = <"BMM_SCHEMA_STATE">
		documentation = <"Enumeration of processing states of a `BMM_SCHEMA` used by creation and validation routines in `BMM_SCHEMA`.">
		ancestors = <"String", ...>
		item_names = <"State_created", "State_validated_created", "State_includes_pending", "State_includes_processed">
		item_documentations = <"Initial state directly after instantiation of schema.", "Initial validation pass after instantiation.", "State of schema processing if there are still included schemas to process.", "State when all included schemas have been processed.">
	>
>