bmm_version = <"2.4">
rm_publisher = <"openehr">
schema_name = <"am">
rm_release = <"2.3.0">
schema_revision = <"2.3.0.2">
schema_lifecycle_state = <"stable">
schema_description = <"openEHR Archetype Model">
schema_author = <"Thomas Beale <thomas.beale@openehr.org>, code-generator">
includes = <
	["openehr_base_1.2.0"] = <
		id = <"openehr_base_1.2.0">
	>
	["openehr_lang_1.0.0"] = <
		id = <"openehr_lang_1.0.0">
	>
>
packages = <
	["org.openehr.am.aom2"] = <
		name = <"org.openehr.am.aom2">
		packages = <
			["archetype"] = <
				name = <"archetype">
				classes = <"ARCHETYPE", "AUTHORED_ARCHETYPE", "TEMPLATE", "OPERATIONAL_TEMPLATE", "TEMPLATE_OVERLAY", "ARCHETYPE_HRID">
			>
			["constraint_model"] = <
				name = <"constraint_model">
				classes = <"ARCHETYPE_CONSTRAINT", "C_OBJECT", "C_ATTRIBUTE", "C_DEFINED_OBJECT", "C_COMPLEX_OBJECT_PROXY", "ARCHETYPE_SLOT", "C_PRIMITIVE_OBJECT", "SIBLING_ORDER", "C_ATTRIBUTE_TUPLE", "C_PRIMITIVE_TUPLE", "C_SECOND_ORDER", "C_ARCHETYPE_ROOT", "C_COMPLEX_OBJECT", "ARCHETYPE_ID_CONSTRAINT">
				packages = <
					["primitive"] = <
						name = <"primitive">
						classes = <"C_BOOLEAN", "C_STRING", "C_INTEGER", "C_REAL", "C_ORDERED", "C_TERMINOLOGY_CODE", "C_TEMPORAL", "C_TIME", "C_DATE", "C_DATE_TIME", "C_DURATION", "C_TEMPORAL_DEFINITIONS", "CONSTRAINT_STATUS">
					>
				>
			>
			["terminology"] = <
				name = <"terminology">
				classes = <"ARCHETYPE_TERM", "TERMINOLOGY_RELATION", "VALUE_SET", "ARCHETYPE_TERMINOLOGY">
			>
			["definitions"] = <
				name = <"definitions">
				classes = <"ADL_CODE_DEFINITIONS", ...>
			>
			["rm_overlay"] = <
				name = <"rm_overlay">
				classes = <"RM_ATTRIBUTE_VISIBILITY", "RM_OVERLAY", "VISIBILITY_TYPE">
			>
			["persistence"] = <
				name = <"persistence">
				packages = <
					["constraint_model"] = <
						name = <"constraint_model">
						classes = <"P_ARCHETYPE_CONSTRAINT", "P_C_OBJECT", "P_C_ATTRIBUTE", "P_C_DEFINED_OBJECT", "P_C_COMPLEX_OBJECT_PROXY", "P_ARCHETYPE_SLOT", "P_C_PRIMITIVE_OBJECT", "P_C_COMPLEX_OBJECT", "P_C_ATTRIBUTE_TUPLE", "P_C_ARCHETYPE_ROOT">
					>
					["primitive"] = <
						name = <"primitive">
						classes = <"P_C_BOOLEAN", "P_C_STRING", "P_C_INTEGER", "P_C_REAL", "P_C_ORDERED", "P_C_TERMINOLOGY_CODE", "P_C_TEMPORAL", "P_C_TIME", "P_C_DATE", "P_C_DATE_TIME", "P_C_DURATION">
					>
					["archetype"] = <
						name = <"archetype">
						classes = <"P_ARCHETYPE", "P_AUTHORED_ARCHETYPE", "P_TEMPLATE", "P_OPERATIONAL_TEMPLATE", "P_ARCHETYPE_HRID", "P_AUTHORED_RESOURCE">
					>
					["terminology"] = <
						name = <"terminology">
						classes = <"P_ARCHETYPE_TERMINOLOGY", ...>
					>
				>
			>
			["profile"] = <
				name = <"profile">
				classes = <"AOM_PROFILE", "AOM_TYPE_MAPPING", "AOM_PROPERTY_MAPPING">
			>
			["rules"] = <
				name = <"rules">
				classes = <"EXPR_ARCHETYPE_ID_CONSTRAINT", "EXPR_ARCHETYPE_REF", "EXPR_CONSTRAINT">
			>
		>
	>
>
class_definitions = <
	["ARCHETYPE"] = <
		name = <"ARCHETYPE">
		documentation = <"The `ARCHETYPE` class defines the core formal model of the root object of any archetype or template. It includes only basic identification information, and otherwise provides the structural connections from the Archetype to its constituent parts, i.e. definition (a `C_COMPLEX_OBJECT`), terminology (`ARCHEYTPE_TERMINOLOGY`) and so on. 
It is the parent class of all concrete types of archetype.">
		is_abstract = <True>
		properties = <
			["parent_archetype_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"parent_archetype_id">
				documentation = <"Archetype reference of the specialisation parent of this archetype, if applicable. May take the form of an archetype interface identifier, i.e. the identifier up to the major version only, or may be a full archetype identifier.">
				type = <"String">
			>
			["archetype_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"archetype_id">
				documentation = <"Identifier of this archetype.">
				is_mandatory = <True>
				type = <"ARCHETYPE_HRID">
			>
			["is_differential"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_differential">
				documentation = <"Flag indicating whether this archetype is differential or flat in its contents. Top-level source archetypes have this flag set to True.">
				is_mandatory = <True>
				type = <"Boolean">
			>
			["definition"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"definition">
				documentation = <"Root node of the definition of this archetype.">
				is_mandatory = <True>
				type = <"C_COMPLEX_OBJECT">
			>
			["terminology"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"terminology">
				documentation = <"The terminology of the archetype.">
				is_mandatory = <True>
				type = <"ARCHETYPE_TERMINOLOGY">
			>
			["rules"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"rules">
				documentation = <"Rules relating to this archetype. Statements are expressed in first order predicate logic, and usually refer to at least two attributes.">
				type_def = <
					container_type = <"List">
					type = <"STATEMENT_SET">
				>
				cardinality = <|>=0|>
			>
			["rm_overlay"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_overlay">
				type = <"RM_OVERLAY">
			>
		>
		functions = <
			["concept_code"] = <
				name = <"concept_code">
				documentation = <"The concept code of the root object of the archetype, also standing for the concept of the archetype as a whole.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
				post_conditions = <
					["post-condition"] = <"Result.is_equal (definition.node_id)">
				>
			>
			["physical_paths"] = <
				name = <"physical_paths">
				documentation = <"Set of language-independent paths extracted from archetype. Paths obey Xpath-like syntax and are formed from alternations of `C_OBJECT._node_id_` and `C_ATTRIBUTE._rm_attribute_name_` values. ">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["logical_paths"] = <
				name = <"logical_paths">
				documentation = <"Set of language-dependent paths extracted from archetype. Paths obey the same syntax as physical_paths, but with node_ids replaced by their meanings from the terminology. ">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				parameters = <
					["lang"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"lang">
						type = <"String">
					>
				>
			>
			["specialisation_depth"] = <
				name = <"specialisation_depth">
				documentation = <"Specialisation depth of this archetype; larger than 0 if this archetype has a parent. Derived from terminology.specialisation_depth.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
				post_conditions = <
					["post-condition"] = <"Result = terminology.specialisation_depth">
				>
			>
			["is_specialised"] = <
				name = <"is_specialised">
				documentation = <"True if this archetype is a specialisation of another. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["post-condition"] = <"Result implies parent_archetype_hrid /= Void">
				>
			>
		>
		invariants = <
			["Invariant_concept_valid"] = <"terminology.has_term_code (concept_code)">
			["Invariant_specialisation_validity"] = <"is_specialised implies specialisation_depth > 0">
		>
	>
	["AUTHORED_ARCHETYPE"] = <
		name = <"AUTHORED_ARCHETYPE">
		documentation = <"Root object of a standalone, authored archetype, including all meta-data, description, other identifiers and lifecycle.">
		ancestors = <"ARCHETYPE", "AUTHORED_RESOURCE">
		properties = <
			["adl_version"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"adl_version">
				documentation = <"ADL version if archetype was read in from an ADL sharable archetype.">
				type = <"String">
			>
			["build_uid"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"build_uid">
				documentation = <"Unique identifier of this archetype artefact instance. A new identifier is assigned every time the content is changed by a tool. Used by tools to distinguish different revisions and/or interim snapshots of the same artefact.">
				is_mandatory = <True>
				type = <"UUID">
			>
			["rm_release"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_release">
				documentation = <"Semver.org compatible release of the most recent reference model release on which the archetype in its current version is based. This does not imply conformance only to this release, since an archetype may be valid with respect to multiple releases of a reference model.">
				is_mandatory = <True>
				type = <"String">
			>
			["is_generated"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_generated">
				documentation = <"If True, indicates that this artefact was machine-generated from some other source, in which case, tools would expect to overwrite this artefact on a new generation. Editing tools should set this value to False when a user starts to manually edit an archetype.">
				is_mandatory = <True>
				type = <"Boolean">
			>
			["other_meta_data"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"other_meta_data">
				is_mandatory = <True>
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
		>
		invariants = <
			["Invariant_adl_version_validity"] = <"valid_version_id (adl_version)">
			["Invariant_rm_release"] = <"valid_version_id (rm_release)">
			["Description_validity"] = <"description /= Void">
		>
	>
	["TEMPLATE"] = <
		name = <"TEMPLATE">
		documentation = <"Class representing source template, i.e. a kind of archetype that may include template overlays, and may be restricted by tools to only defining mandations, prohibitions, and restrictions on elements already defined in the flat parent.">
		ancestors = <"AUTHORED_ARCHETYPE", ...>
		properties = <
			["overlays"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"overlays">
				documentation = <"Overlay archetypes, i.e. partial archetypes that include full definition and terminology, but logically derive all their meta-data from the owning template.">
				type_def = <
					container_type = <"List">
					type = <"TEMPLATE_OVERLAY">
				>
				cardinality = <|>=0|>
			>
		>
		invariants = <
			["Inv_is_specialised"] = <"is_specialised">
		>
	>
	["OPERATIONAL_TEMPLATE"] = <
		name = <"OPERATIONAL_TEMPLATE">
		documentation = <"Root object of an operational template. An operational template is derived from a `TEMPLATE` definition and the `ARCHETYPEs` and/or `TEMPLATE_OVERLAYs` mentioned by that template by a process of flattening, and potentially removal of unneeded languages and terminologies.

An operational template is used for generating and validating RM-canonical instance data, and also as a source artefact for generating other downstream technical artefacts, including XML schemas, APIs and UI form definitions.">
		ancestors = <"AUTHORED_ARCHETYPE", ...>
		properties = <
			["component_terminologies"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"component_terminologies">
				documentation = <"Compendium of flattened terminologies of archetypes  referenced from this template, keyed by archetype identifier. This will almost always be present in a template.">
				type_def = <
					generic_parameters = <"String", "ARCHETYPE_TERMINOLOGY">
					root_type = <"Hash">
				>
			>
			["terminology_extracts"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"terminology_extracts">
				documentation = <"Compendium of flattened terminology extracts (i.e. from external terminologies) from archetypes referenced from this template, keyed by archetype identifier.">
				type_def = <
					generic_parameters = <"String", "ARCHETYPE_TERMINOLOGY">
					root_type = <"Hash">
				>
			>
		>
		functions = <
			["component_terminology"] = <
				name = <"component_terminology">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"ARCHETYPE_TERMINOLOGY">
				>
				parameters = <
					["an_id"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"an_id">
						type = <"String">
					>
				>
				post_conditions = <
					["Inv_is_specialised"] = <"is_specialised">
				>
			>
		>
		invariants = <
			["Specialisation_validity"] = <"is_specialised">
		>
	>
	["TEMPLATE_OVERLAY"] = <
		name = <"TEMPLATE_OVERLAY">
		documentation = <"A concrete form of the bare `ARCHETYPE` class, used to represent overlays in a source template. Overlays have no meta-data of their own, and are instead documented by their owning template.">
		ancestors = <"ARCHETYPE", ...>
		invariants = <
			["Inv_is_specialised"] = <"is_specialised">
		>
	>
	["ARCHETYPE_HRID"] = <
		name = <"ARCHETYPE_HRID">
		documentation = <"Human-readable structured identifier (HRID) for an archetype or template.">
		properties = <
			["namespace"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"namespace">
				documentation = <"Reverse domain name namespace identifier.">
				type = <"String">
			>
			["rm_publisher"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_publisher">
				documentation = <"Name of the Reference Model publisher.">
				is_mandatory = <True>
				type = <"String">
			>
			["rm_package"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_package">
				documentation = <"Name of the package in whose reachability graph the `_rm_class_` class is found (there can be more than one possibility in many reference models).">
				is_mandatory = <True>
				type = <"String">
			>
			["rm_class"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_class">
				documentation = <"Name of the root class of this archetype.">
				is_mandatory = <True>
				type = <"String">
			>
			["concept_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"concept_id">
				documentation = <"The short concept name of the archetype as used in the multi-axial `_archetype_hrid_`.">
				is_mandatory = <True>
				type = <"String">
			>
			["release_version"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"release_version">
				documentation = <"The full numeric version of this archetype consisting of 3 parts, e.g. `\"1.8.2\"`. The `_archetype_hrid_` feature includes only the major version.">
				is_mandatory = <True>
				type = <"String">
			>
			["version_status"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"version_status">
				documentation = <"The status of the version, i.e.:

* released: (empty string)
* release_candidate: `\"rc\"`
* alpha: `\"alpha\"`
* beta: `\"beta\"`">
				is_mandatory = <True>
				type = <"VERSION_STATUS">
			>
			["build_count"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"build_count">
				documentation = <"The build count since last increment of any version part.">
				is_mandatory = <True>
				type = <"String">
			>
		>
		functions = <
			["semantic_id"] = <
				name = <"semantic_id">
				documentation = <"The 'interface' form of the HRID, i.e. down to the major version.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["physical_id"] = <
				name = <"physical_id">
				documentation = <"The 'physical' form of the HRID, i.e. with complete version information specified by `_version_id()_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["version_id"] = <
				name = <"version_id">
				documentation = <"Full version identifier string, based on `_release_version_`, `_version_status_`, and `_build_count_` e.g. `\"1.8.2-rc.4\"`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["major_version"] = <
				name = <"major_version">
				documentation = <"Major version of this archetype, extracted from `_release_version_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["minor_version"] = <
				name = <"minor_version">
				documentation = <"Minor version of this archetype, extracted from `_release_version_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["patch_version"] = <
				name = <"patch_version">
				documentation = <"Patch version of this archetype, extracted from `_release_version_`. Equivalent to patch version in patch version in `semver.org` sytem.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
		>
		invariants = <
			["Inv_rm_publisher_validity"] = <"not rm_publisher.is_empty">
			["Inv_rm_package_validity"] = <"not rm_package.is_empty">
			["Inv_class_name_validity"] = <"not rm_class.is_empty">
			["Inv_concept_id_validity"] = <"not concept_id.is_empty">
			["Inv_release_version_validity"] = <"valid_version (release_version)">
		>
	>
	["ARCHETYPE_CONSTRAINT"] = <
		name = <"ARCHETYPE_CONSTRAINT">
		documentation = <"Abstract parent of all constraint model types. Defines conformance and congruence function signatures. ">
		ancestors = <"ADL_CODE_DEFINITIONS", ...>
		is_abstract = <True>
		properties = <
			["parent"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"parent">
				documentation = <"Parent node, except in the case of the top of a tree, i.e. root `C_COMPLEX_OBJECT` of an archetype definition.">
				type = <"ARCHETYPE_CONSTRAINT">
			>
			["soc_parent"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"soc_parent">
				type = <"C_SECOND_ORDER">
			>
		>
		functions = <
			["is_prohibited"] = <
				name = <"is_prohibited">
				documentation = <"True if this node is prohibited. Implemented in subtypes.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["has_path"] = <
				name = <"has_path">
				documentation = <"True if the relative path `_a_path_` exists at this node.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_path"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_path">
						type = <"String">
					>
				>
			>
			["path"] = <
				name = <"path">
				documentation = <"Path of this node relative to root of archetype.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["c_conforms_to"] = <
				name = <"c_conforms_to">
				documentation = <"True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. 
Typically used during validation of specialised archetype nodes.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"ARCHETYPE_CONSTRAINT">
					>
					["rmcc"] = (P_BMM_GENERIC_FUNCTION_PARAMETER) <
						name = <"rmcc">
						documentation = <"RM conformance checker - a lambda (i.e. function object) that can compute conformance of type-names within the  Reference Model on which the current archetype is based. The signature provides two arguments representing respectively, the `_rm_type_name_` of the current node and the `_rm_type_name_` of the node being redefined in a specialisation parent archetype.">
						type_def = <
							generic_parameters = <
								[1] = <"Boolean">
								[2] = (P_BMM_GENERIC_TYPE) <
									generic_parameters = <"String", "String">
									root_type = <"TUPLE2">
								>
							>
							root_type = <"FUNCTION">
						>
					>
				>
			>
			["c_congruent_to"] = <
				name = <"c_congruent_to">
				documentation = <"True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. 

Typically used to test if an inherited node locally contains any constraints.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"ARCHETYPE_CONSTRAINT">
					>
				>
			>
			["is_second_order_constrained"] = <
				name = <"is_second_order_constrained">
				documentation = <"True if there is a second order constraint such as a tuple constraint on this node.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"soc_parent /= Void or else (parent /= Void and then parent.is_second_order_constrained)">
				>
			>
			["is_root"] = <
				name = <"is_root">
				documentation = <"True if this node is the root of the tree.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["is_leaf"] = <
				name = <"is_leaf">
				documentation = <"True if this node is a terminal node in the tree structure, i.e. having no child nodes.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
		invariants = <
			["Post"] = <"Result = soc_parent /= Void or parent.soc_parent /= Void">
		>
	>
	["C_OBJECT"] = <
		name = <"C_OBJECT">
		documentation = <"Abstract model of constraint on any kind of object node. ">
		ancestors = <"ARCHETYPE_CONSTRAINT", ...>
		is_abstract = <True>
		properties = <
			["rm_type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_type_name">
				documentation = <"Reference model type that this node corresponds to. ">
				is_mandatory = <True>
				type = <"String">
			>
			["occurrences"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"occurrences">
				documentation = <"Occurrences of this object node in the data, under the owning attribute. Upper limit can only be greater than 1 if owning attribute has a cardinality of more than 1.
Only set if it overrides the parent archetype in the case of specialised archetypes, or else the occurrences inferred from the underlying reference model existence and/or cardinality of the containing attribute.">
				type = <"Multiplicity_interval">
			>
			["node_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"node_id">
				documentation = <"Semantic identifier of this node, used to distinguish sibling nodes. All nodes must have a `_node_id_`; for nodes under a container `C_ATTRIBUTE`, the id must be an id-code must be defined in the archetype terminology. For valid structures, all node ids are id-codes.

For `C_PRIMITIVE_OBJECTs` represented in ADL inline form, this attribute will have the special value `Primitive_node_id`; otherwise it will have the node id read during parsing.">
				is_mandatory = <True>
				type = <"String">
			>
			["is_deprecated"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_deprecated">
				documentation = <"True if this node and by implication all sub-nodes are deprecated for use.">
				type = <"Boolean">
			>
			["sibling_order"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"sibling_order">
				documentation = <"Optional indicator of order of this node with respect to another sibling. Only meaningful in a specialised archetype for a `C_OBJECT` within a `C_ATTRIBUTE` with `_is_multiple_ = True`.">
				type = <"SIBLING_ORDER">
			>
		>
		functions = <
			["specialisation_depth"] = <
				name = <"specialisation_depth">
				documentation = <"Level of specialisation of this archetype node, based on its `_node_id_`. The value 0 corresponds to non-specialised, 1 to first-level specialisation and so on. The level is the same as the number of ‘.’ characters in the node_id code. If `_node_id_` is not set, the return value is -1, signifying that the specialisation level should be determined from the nearest parent `C_OBJECT` node having a node_id.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["effective_occurrences"] = <
				name = <"effective_occurrences">
				documentation = <"Compute effective occurrences, where no local occurrences constraint set. If the owning `C_ATTRIBUTE._cardinality_` is set, use its upper value, else use RM multiplicity of the owning attribute.

If local `occurrences` not set, always assume 0 as the lower bound.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Multiplicity_interval">
				>
			>
			["c_conforms_to"] = <
				name = <"c_conforms_to">
				documentation = <"True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. 
Typically used during validation of specialised archetype nodes.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_OBJECT">
					>
					["rmcc"] = (P_BMM_GENERIC_FUNCTION_PARAMETER) <
						name = <"rmcc">
						documentation = <"Reference Model conformance checker agent (lambda).">
						type_def = <
							generic_parameters = <
								[1] = <"Boolean">
								[2] = (P_BMM_GENERIC_TYPE) <
									generic_parameters = <"String", "String">
									root_type = <"TUPLE2">
								>
							>
							root_type = <"FUNCTION">
						>
					>
				>
			>
			["c_congruent_to"] = <
				name = <"c_congruent_to">
				documentation = <"True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. 

Typically used to test if an inherited node locally contains any constraints.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"ARCHETYPE_CONSTRAINT">
					>
				>
			>
			["occurrences_conforms_to"] = <
				name = <"occurrences_conforms_to">
				documentation = <"True if this node `_occurrences_` conforms to `_other.occurrences_`; `other` is assumed to be in a flat archetype.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						documentation = <"`C_OBJECT` from a flat parent archetype.">
						type = <"C_OBJECT">
					>
				>
			>
			["node_id_conforms_to"] = <
				name = <"node_id_conforms_to">
				documentation = <"True if this node id conforms to `_other.node_id_`, which includes the ids being identical; `_other_` is assumed to be in a flat archetype.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_OBJECT">
					>
				>
				post_conditions = <
					["Post"] = <"Result = codes_conformant (node_id, other.node_id)">
				>
			>
			["is_prohibited"] = <
				name = <"is_prohibited">
				documentation = <"True if this `C_OBJECT` node is prohibited, i.e. if its `_occurrences_` is `0..0`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result = occurrences /= Void and then occurrences.is_prohibited">
				>
			>
		>
	>
	["C_ATTRIBUTE"] = <
		name = <"C_ATTRIBUTE">
		documentation = <"Abstract model of constraint on any kind of attribute in a class model.">
		ancestors = <"ARCHETYPE_CONSTRAINT", ...>
		properties = <
			["rm_attribute_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_attribute_name">
				documentation = <"Reference model attribute within the enclosing type represented by a `C_OBJECT`.">
				is_mandatory = <True>
				type = <"String">
			>
			["existence"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"existence">
				documentation = <"Constraint settable on every attribute, regardless of whether it is singular or of a container type, which indicates whether its target object exists or not (i.e. is mandatory or not). Only set if it overrides the underlying reference model or parent archetype in the case of specialised archetypes.">
				type = <"Multiplicity_interval">
			>
			["children"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"children">
				documentation = <"Child `C_OBJECT` nodes. Each such node represents a constraint on the type of this attribute in its reference model. Multiples occur both for multiple items in the case of container attributes, and alternatives in the case of singular attributes. ">
				type_def = <
					container_type = <"List">
					type = <"C_OBJECT">
				>
				cardinality = <|>=0|>
			>
			["differential_path"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"differential_path">
				documentation = <"Path to the parent object of this attribute (i.e. doesn’t include the name of this attribute). Used only for attributes in differential form, specialised archetypes. Enables only the re-defined parts of a specialised archetype to be expressed, at the path where they occur.">
				type = <"String">
			>
			["cardinality"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"cardinality">
				documentation = <"Cardinality constraint of attribute, if a container attribute.">
				type = <"Cardinality">
			>
			["is_multiple"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_multiple">
				documentation = <"Flag indicating whether this attribute constraint is on a container (i.e. multiply-valued) attribute.">
				is_mandatory = <True>
				type = <"Boolean">
			>
		>
		functions = <
			["any_allowed"] = <
				name = <"any_allowed">
				documentation = <"True if there is no effective constraint on the children of the RM attribute to which this `C_ATTRIBUTE` refers.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result := children.is_empty and not is_prohibited">
				>
			>
			["is_mandatory"] = <
				name = <"is_mandatory">
				documentation = <"True if this `C_ATTRIBUTE` has an existence constraint of 1..1, i.e. mandation.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result = existence /= Void and then existence.is_mandatory">
				>
			>
			["rm_attribute_path"] = <
				name = <"rm_attribute_path">
				documentation = <"Path of this attribute with respect to owning `C_OBJECT`, including differential path where applicable.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["is_single"] = <
				name = <"is_single">
				documentation = <"True if this node logically represents a single-valued attribute. Evaluated as not `_is_multiple_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["c_congruent_to"] = <
				name = <"c_congruent_to">
				documentation = <"True if constraints represented by this node contain no further redefinitions with respect to the node other, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. 

Typically used to test if an inherited node locally contains any constraints.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"ARCHETYPE_CONSTRAINT">
					>
				>
				post_conditions = <
					["Post"] = <"Result = existence = Void and ((is_single and other.is_single) or (is_multiple and other.is_multiple and cardinality = Void))">
				>
			>
			["c_conforms_to"] = <
				name = <"c_conforms_to">
				documentation = <"True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. 
Typically used during validation of specialised archetype nodes.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"ARCHETYPE_CONSTRAINT">
					>
					["rmcc"] = (P_BMM_GENERIC_FUNCTION_PARAMETER) <
						name = <"rmcc">
						type_def = <
							generic_parameters = <
								[1] = <"Boolean">
								[2] = (P_BMM_GENERIC_TYPE) <
									generic_parameters = <"String", "String">
									root_type = <"TUPLE2">
								>
							>
							root_type = <"FUNCTION">
						>
					>
				>
				post_conditions = <
					["Post"] = <"Result = existence_conforms_to (other) and ((is_single and other.is_single) or else (is_multiple and cardinality_conforms_to (other)))">
				>
			>
			["is_prohibited"] = <
				name = <"is_prohibited">
				documentation = <"True if this `C_ATTRIBUTE` has an existence constraint of `0..0`, i.e. prohibition.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result = existence /= Void and then existence.is_prohibited">
				>
			>
		>
	>
	["C_DEFINED_OBJECT"] = <
		name = <"C_DEFINED_OBJECT">
		documentation = <"Abstract parent type of `C_OBJECT` subtypes that are defined by value, i.e. whose definitions are actually in the archetype rather than being by reference. ">
		ancestors = <"C_OBJECT", ...>
		is_abstract = <True>
		properties = <
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				documentation = <"Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.">
				type = <"Any">
			>
		>
		functions = <
			["any_allowed"] = <
				name = <"any_allowed">
				documentation = <"True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["valid_value"] = <
				name = <"valid_value">
				documentation = <"True if `_a_value_` is valid with respect to constraint expressed in concrete instance of this type.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_value"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_value">
						type = <"Any">
					>
				>
			>
			["prototype_value"] = <
				name = <"prototype_value">
				documentation = <"Generate a prototype value from this constraint object.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Any">
				>
			>
			["has_default_value"] = <
				name = <"has_default_value">
				documentation = <"True if there is an assumed value.
">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
		invariants = <
			["Inv_valid_default_value"] = <"valid_value (default_value)">
		>
	>
	["C_COMPLEX_OBJECT_PROXY"] = <
		name = <"C_COMPLEX_OBJECT_PROXY">
		documentation = <"A constraint defined by proxy, using a reference to an object constraint defined elsewhere in the same archetype. Note that since this object refers to another node, there are two objects with available occurrences values. The local occurrences value on a `COMPLEX_OBJECT_PROXY` should always be used; when setting this from a serialised form, if no occurrences is mentioned, the target occurrences should be used (not the standard default of `{1..1}`); otherwise the locally specified occurrences should be used as normal. When serialising out, if the occurrences is the same as that of the target, it can be left out. ">
		ancestors = <"C_OBJECT", ...>
		properties = <
			["target_path"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"target_path">
				documentation = <"Reference to an object node using archetype path notation.">
				is_mandatory = <True>
				type = <"String">
			>
		>
		functions = <
			["use_target_occurrences"] = <
				name = <"use_target_occurrences">
				documentation = <"True if target occurrences are to be used as the value of occurrences in this object; by the time of runtime use, the target occurrences value has to be set into this object.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result = (occurrences = Void)">
				>
			>
			["occurrences_conforms_to"] = <
				name = <"occurrences_conforms_to">
				documentation = <"True if this node occurrences conforms to `_other.occurrences_`; `_other_` is assumed to be in a flat archetype.

If `_other_` is a `C_COMPLEX_OBJECT`, then always `True`, since if occurrences defined on proxy node, it is an override of  the occurrences on the target, and it doesn't have to conform to anything except the containing attribute's cardinality. However, if `_other_` is also a `C_COMPLEX_OBJECT` then the override is of another use_node, and normal occurrences apply
">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						documentation = <"`C_OBJECT` from a flat parent archetype.">
						type = <"C_OBJECT">
					>
				>
			>
		>
	>
	["ARCHETYPE_SLOT"] = <
		name = <"ARCHETYPE_SLOT">
		documentation = <"Constraint describing a 'slot' where another archetype can occur. ">
		ancestors = <"C_OBJECT", ...>
		properties = <
			["includes"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"includes">
				documentation = <"List of constraints defining other archetypes that could be included at this point. Represented as an `ASSERTION` containing an expression of the form  `EXPR_ARCHETYPE_REF matches EXPR_ARCHETYPE_ID_CONSTRAINT`.">
				type_def = <
					container_type = <"List">
					type = <"ASSERTION">
				>
				cardinality = <|>=0|>
			>
			["excludes"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"excludes">
				documentation = <"List of constraints defining other archetypes that cannot be included at this point. Represented as an `ASSERTION` containing an expression of the form  `EXPR_ARCHETYPE_REF matches EXPR_ARCHETYPE_ID_CONSTRAINT`.">
				type_def = <
					container_type = <"List">
					type = <"ASSERTION">
				>
				cardinality = <|>=0|>
			>
			["is_closed"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_closed">
				documentation = <"True if this slot specification in this artefact is closed to further filling either in further specialisations or at runtime. Default value False, i.e. unless explicitly set, a slot remains open.">
				is_mandatory = <True>
				type = <"Boolean">
			>
		>
		functions = <
			["any_allowed"] = <
				name = <"any_allowed">
				documentation = <"True if no constraints stated, and slot is not closed.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
	>
	["C_PRIMITIVE_OBJECT"] = <
		name = <"C_PRIMITIVE_OBJECT">
		documentation = <"Parent of types representing constraints on primitive types.

Instances of this type represented in ADL inline form, the `_node_id_` attribute will have the special value `Primitive_node_id`; otherwise it will have the node id read during parsing.">
		ancestors = <"C_DEFINED_OBJECT", ...>
		is_abstract = <True>
		properties = <
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				documentation = <"Value to be assumed if none sent in data.">
				type = <"Any">
			>
			["is_enumerated_type_constraint"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_enumerated_type_constraint">
				documentation = <"True if this object represents a constraint on an enumerated type from the reference model, where the latter is assumed to be based on a primitive type, generally Integer or String.">
				type = <"Boolean">
			>
			["constraint"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"constraint">
				documentation = <"Constraint represented by this object; redefine in descendants.">
				is_mandatory = <True>
				type = <"Any">
			>
		>
		functions = <
			["has_assumed_value"] = <
				name = <"has_assumed_value">
				documentation = <"True if there is an assumed value.
">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["constrained_typename"] = <
				name = <"constrained_typename">
				documentation = <"Generate name of native type that is constrained by this `C_XXX` type. For most types, it is the `C_XXX` typename without the `C_`, i.e. `XXX`. E.g. `C_INTEGER` -> `Integer`. For the date/time types the mapping is different.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["c_conforms_to"] = <
				name = <"c_conforms_to">
				documentation = <"True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. 
Typically used during validation of specialised archetype nodes.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_PRIMITIVE_OBJECT">
					>
					["rmcc"] = (P_BMM_GENERIC_FUNCTION_PARAMETER) <
						name = <"rmcc">
						documentation = <"Reference Model conformance checker lambda.">
						type_def = <
							generic_parameters = <
								[1] = <"Boolean">
								[2] = (P_BMM_GENERIC_TYPE) <
									generic_parameters = <"String", "String">
									root_type = <"TUPLE2">
								>
							>
							root_type = <"FUNCTION">
						>
					>
				>
			>
			["c_value_conforms_to"] = <
				name = <"c_value_conforms_to">
				documentation = <"True if this node expresses a value constraint that conforms to that of `other`. Effected in descendants.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_PRIMITIVE_OBJECT">
					>
				>
			>
			["c_congruent_to"] = <
				name = <"c_congruent_to">
				documentation = <"True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. 

Typically used to test if an inherited node locally contains any constraints.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_PRIMITIVE_OBJECT">
					>
				>
			>
			["c_value_congruent_to"] = <
				name = <"c_value_congruent_to">
				documentation = <"True if this node expresses the same value constraint as `other`. Effected in descendants.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_PRIMITIVE_OBJECT">
					>
				>
			>
		>
		invariants = <
			["Inv_valid_assumed_value"] = <"valid_value (assumed_value)">
		>
	>
	["SIBLING_ORDER"] = <
		name = <"SIBLING_ORDER">
		documentation = <"Defines the order indicator that can be used on a `C_OBJECT` within a container attribute in a specialised archetype to indicate its order with respect to a sibling defined in a higher specialisation level.

Misuse: This type cannot be used on a `C_OBJECT` other than one within a container attribute in a specialised archetype.">
		properties = <
			["is_before"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_before">
				documentation = <"True if the order relationship is ‘before’, if False, it is ‘after’.">
				is_mandatory = <True>
				type = <"Boolean">
			>
			["sibling_node_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"sibling_node_id">
				documentation = <"Node identifier of sibling before or after which this node should come.">
				is_mandatory = <True>
				type = <"String">
			>
		>
		functions = <
			["is_after"] = <
				name = <"is_after">
				documentation = <"True if the order relationship is `_after_`, computed as the negation of `_is_before_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
		>
	>
	["C_ATTRIBUTE_TUPLE"] = <
		name = <"C_ATTRIBUTE_TUPLE">
		documentation = <"Object representing a constraint on an attribute tuple, i.e. a group of attributes that are constrained together. Typically used for representing co-varying constraints like `{units, range}` constraints.">
		ancestors = <"C_SECOND_ORDER", ...>
		properties = <
			["tuples"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"tuples">
				documentation = <"Tuple definitions.">
				type_def = <
					container_type = <"List">
					type = <"C_PRIMITIVE_TUPLE">
				>
				cardinality = <|>=0|>
			>
			["members"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"members">
				documentation = <"List of `C_ATTRIBUTEs` forming the definition of the tuple.">
				type_def = <
					container_type = <"List">
					type = <"C_ATTRIBUTE">
				>
				cardinality = <|>=0|>
			>
		>
		functions = <
			["c_conforms_to"] = <
				name = <"c_conforms_to">
				documentation = <"True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_ATTRIBUTE_TUPLE">
					>
					["rmcc"] = (P_BMM_GENERIC_FUNCTION_PARAMETER) <
						name = <"rmcc">
						documentation = <"RM conformance checker agent.">
						type_def = <
							generic_parameters = <
								[1] = <"Boolean">
								[2] = (P_BMM_GENERIC_TYPE) <
									generic_parameters = <"String", "String">
									root_type = <"TUPLE2">
								>
							>
							root_type = <"FUNCTION">
						>
					>
				>
			>
			["c_congruent_to"] = <
				name = <"c_congruent_to">
				documentation = <"True if constraints represented by this node contain no further redefinitions with respect to the node other. Typically used to test if an inherited node locally contains any constraints.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_SECOND_ORDER">
					>
				>
			>
		>
	>
	["C_PRIMITIVE_TUPLE"] = <
		name = <"C_PRIMITIVE_TUPLE">
		documentation = <"Class representing a single object tuple instance in a tuple constraint. Each such instance is a vector of object constraints, where each member (each `C_PRIMITIVE_OBJECT`) corresponds to one of the `C_ATTRIBUTEs` referred to by the owning `C_ATTRIBUTE_TUPLE`.">
		ancestors = <"C_SECOND_ORDER", ...>
		properties = <
			["members"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"members">
				documentation = <"Object constraint members of this tuple group.">
				is_mandatory = <True>
				type_def = <
					container_type = <"List">
					type = <"C_PRIMITIVE_OBJECT">
				>
				cardinality = <|>=1|>
			>
		>
		functions = <
			["c_conforms_to"] = <
				name = <"c_conforms_to">
				documentation = <"True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_PRIMITIVE_TUPLE">
					>
					["rmcc"] = (P_BMM_GENERIC_FUNCTION_PARAMETER) <
						name = <"rmcc">
						documentation = <"RM conformance checker agent.">
						type_def = <
							generic_parameters = <
								[1] = <"Boolean">
								[2] = (P_BMM_GENERIC_TYPE) <
									generic_parameters = <"String", "String">
									root_type = <"TUPLE2">
								>
							>
							root_type = <"FUNCTION">
						>
					>
				>
			>
			["c_congruent_to"] = <
				name = <"c_congruent_to">
				documentation = <"True if constraints represented by this node contain no further redefinitions with respect to the node other. Typically used to test if an inherited node locally contains any constraints.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_SECOND_ORDER">
					>
				>
			>
		>
	>
	["C_SECOND_ORDER"] = <
		name = <"C_SECOND_ORDER">
		documentation = <"Abstract parent of classes defining second order constraints.">
		is_abstract = <True>
		properties = <
			["members"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"members">
				documentation = <"Members of this second order constrainer. Normally redefined in descendants.">
				type_def = <
					container_type = <"List">
					type = <"ARCHETYPE_CONSTRAINT">
				>
				cardinality = <|>=0|>
			>
		>
		functions = <
			["c_conforms_to"] = <
				name = <"c_conforms_to">
				documentation = <"True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. Typically used during validation of specialised archetype nodes.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_SECOND_ORDER">
					>
					["rmcc"] = (P_BMM_GENERIC_FUNCTION_PARAMETER) <
						name = <"rmcc">
						documentation = <"RM conformance checker agent - a lambda (i.e. function object) that can compute conformance of type-names within the  Reference Model on which the current archetype is based. The signature provides two arguments representing respectively, the `_rm_type_name_` of the current node and the `_rm_type_name_` of the node being redefined in a specialisation parent archetype.">
						type_def = <
							generic_parameters = <
								[1] = <"Boolean">
								[2] = (P_BMM_GENERIC_TYPE) <
									generic_parameters = <"String", "String">
									root_type = <"TUPLE2">
								>
							>
							root_type = <"FUNCTION">
						>
					>
				>
			>
			["c_congruent_to"] = <
				name = <"c_congruent_to">
				documentation = <"True if constraints represented by this node contain no further redefinitions with respect to the node other. Typically used to test if an inherited node locally contains any constraints.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_SECOND_ORDER">
					>
				>
			>
		>
	>
	["C_ARCHETYPE_ROOT"] = <
		name = <"C_ARCHETYPE_ROOT">
		documentation = <"A specialisation of `C_COMPLEX_OBJECT` whose node_id attribute is an archetype identifier rather than the normal internal node code (i.e. id-code).

Used in two situations. The first is to represent an 'external reference' to an archetype from within another archetype or template. This supports re-use. The second use is within a template, where it is used as a slot-filler. 

For a new external reference, the `_node_id_` is set in the normal way, i.e. with a new code at the specialisation level of the archetype.

For a slot-filler or a redefined external reference, the `_node_id_` is set to a specialised version of the `_node_id_` of the node being specialised, allowing matching to occur during flattening.

In all uses within source archetypes and templates, the `_children_` attribute is `Void`.

In an operational template, the `_node_id_` is converted to the `_archetype_ref_`, and the structure contains the result of flattening any template overlay structure and the underlying flat archetype.
">
		ancestors = <"C_COMPLEX_OBJECT", ...>
		properties = <
			["archetype_ref"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"archetype_ref">
				documentation = <"Reference to archetype is being used to fill a slot or redefine an external reference. Typically an 'interface' archetype id, i.e. identifier with partial version information.">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["C_COMPLEX_OBJECT"] = <
		name = <"C_COMPLEX_OBJECT">
		documentation = <"Constraint on complex objects, i.e. any object that consists of other object constraints.">
		ancestors = <"C_DEFINED_OBJECT", ...>
		properties = <
			["attributes"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"attributes">
				documentation = <"List of constraints on attributes of the reference model type represented by this object.">
				type_def = <
					container_type = <"List">
					type = <"C_ATTRIBUTE">
				>
				cardinality = <|>=0|>
			>
			["attribute_tuples"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"attribute_tuples">
				documentation = <"List of attribute tuple constraints under this object constraint, if any.">
				type_def = <
					container_type = <"List">
					type = <"C_ATTRIBUTE_TUPLE">
				>
				cardinality = <|>=0|>
			>
		>
		functions = <
			["any_allowed"] = <
				name = <"any_allowed">
				documentation = <"True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result = attributes.is_empty and not is_prohibited">
				>
			>
			["c_conforms_to"] = <
				name = <"c_conforms_to">
				documentation = <"True if constraints represented by this node, ignoring any sub-parts, are narrower or the same as other. 
Typically used during validation of specialised archetype nodes.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_COMPLEX_OBJECT">
					>
					["rmcc"] = (P_BMM_GENERIC_FUNCTION_PARAMETER) <
						name = <"rmcc">
						documentation = <"Reference Model conformance checker agent (lambda).">
						type_def = <
							generic_parameters = <
								[1] = <"Boolean">
								[2] = (P_BMM_GENERIC_TYPE) <
									generic_parameters = <"String", "String">
									root_type = <"TUPLE2">
								>
							>
							root_type = <"FUNCTION">
						>
					>
				>
			>
			["c_congruent_to"] = <
				name = <"c_congruent_to">
				documentation = <"True if constraints represented by this node contain no further redefinitions with respect to the node `_other_`, with the exception of `_node_id_` redefinition in `C_OBJECT` nodes. 

Typically used to test if an inherited node locally contains any constraints.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_COMPLEX_OBJECT">
					>
				>
			>
		>
	>
	["ARCHETYPE_ID_CONSTRAINT"] = <
		name = <"ARCHETYPE_ID_CONSTRAINT">
		documentation = <"Constraint expression representing a regex constraint on an archetype identifier.">
		properties = <
			["constraint"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"constraint">
				documentation = <"Right hand side of the constraint expression, in the form of a `C_STRING`, i.e. string value constrainer.">
				is_mandatory = <True>
				type = <"C_STRING">
			>
		>
	>
	["C_BOOLEAN"] = <
		name = <"C_BOOLEAN">
		documentation = <"Constraint on instances of `Boolean`. Both attributes cannot be set to False, since this would mean that the Boolean value being constrained cannot be `True` or `False`.">
		ancestors = <"C_PRIMITIVE_OBJECT", ...>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				documentation = <"Boolean constraint - a list of Boolean values.">
				type_def = <
					container_type = <"List">
					type = <"Boolean">
				>
				cardinality = <|>=0|>
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				documentation = <"Assumed Boolean value.">
				type = <"Boolean">
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				documentation = <"Default Boolean value.">
				type = <"Boolean">
			>
		>
		functions = <
			["prototype_value"] = <
				name = <"prototype_value">
				documentation = <"Prototype Boolean value.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["any_allowed"] = <
				name = <"any_allowed">
				documentation = <"True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result = constraint.is_empty">
				>
			>
			["c_value_conforms_to"] = <
				name = <"c_value_conforms_to">
				documentation = <"True if `_other.any_allowed_` or else every constraint in the `_constraint_` list exists in the `_other.constraint_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_BOOLEAN">
					>
				>
			>
			["c_value_congruent_to"] = <
				name = <"c_value_congruent_to">
				documentation = <"True if the items in `_constraint_` are equal in number and identical pair-wise with those in `_other.constraint_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_BOOLEAN">
					>
				>
			>
		>
	>
	["C_STRING"] = <
		name = <"C_STRING">
		documentation = <"Constraint on instances of `String`. ">
		ancestors = <"C_PRIMITIVE_OBJECT", ...>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				documentation = <"String constraint - a list of literal strings and / or regular expression strings delimited by the ‘/’ character.

To represent no constraint, use an empty list, or alternatively, a regex 'any' pattern, i.e. `/.*/`.">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				documentation = <"Default String value.">
				type = <"String">
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				documentation = <"Assumed String value.">
				type = <"String">
			>
		>
		functions = <
			["prototype_value"] = <
				name = <"prototype_value">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"String">
				>
			>
			["valid_value"] = <
				name = <"valid_value">
				documentation = <"True if a_value is valid with respect to constraint expressed in concrete instance of this type. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_value"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_value">
						type = <"String">
					>
				>
			>
			["any_allowed"] = <
				name = <"any_allowed">
				documentation = <"True if `_constraint_` is empty or else contains one String for the regex 'any' pattern.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result = constraint.is_empty or else constraint.count = 1 and constraint.first.is_equal (Regex_any_string)">
				>
			>
			["c_value_conforms_to"] = <
				name = <"c_value_conforms_to">
				documentation = <"True if `_other.any_allowed_` or else every constraint in the `_constraint_` list exists in the `_other.constraint_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_STRING">
					>
				>
			>
			["c_value_congruent_to"] = <
				name = <"c_value_congruent_to">
				documentation = <"True if the items in `_constraint_` are equal in number and identical pair-wise with those in `_other.constraint_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_STRING">
					>
				>
			>
		>
	>
	["C_INTEGER"] = <
		name = <"C_INTEGER">
		documentation = <"Constraint on instances of Integer.">
		ancestors = <"C_ORDERED", ...>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				documentation = <"Formal constraint on `Integer`, in the form of one or more `Interval<Integer>`.

To represent no constraint, use an empty list.">
				type_def = <
					container_type = <"List">
					type_def = (P_BMM_GENERIC_TYPE) <
						generic_parameters = <"Integer", ...>
						root_type = <"Interval">
					>
				>
				cardinality = <|>=0|>
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				documentation = <"Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.">
				type = <"Integer">
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				documentation = <"Value to be assumed if none sent in data.">
				type = <"Real">
			>
		>
	>
	["C_REAL"] = <
		name = <"C_REAL">
		documentation = <"Constraint on instances of Real.">
		ancestors = <"C_ORDERED", ...>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				documentation = <"Formal constraint on `Real`, in the form of one or more `Interval<Real>`.

To represent no constraint, use an empty list.">
				type_def = <
					container_type = <"List">
					type_def = (P_BMM_GENERIC_TYPE) <
						generic_parameters = <"Real", ...>
						root_type = <"Interval">
					>
				>
				cardinality = <|>=0|>
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				documentation = <"Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.">
				type = <"Real">
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				documentation = <"Value to be assumed if none sent in data.">
				type = <"Real">
			>
		>
	>
	["C_ORDERED"] = <
		name = <"C_ORDERED">
		documentation = <"Abstract parent of primitive constrainer classes based on `Ordered` base types, i.e. types like `Integer`, `Real`, and the Date/Time types. The model constraint is a List of Intervals, which may include point Intervals, and acts as a efficient and formally tractable representation of any number of point values and/or contiguous intervals of an ordered value domain.

In its simplest form, the constraint accessor returns just a single point `Interval<T>` object, representing a single value.

The next simplest form is a single proper `Interval <T>` (i.e. normal two-sided or half-open interval). The most complex form is a list of any combination of point and proper intervals.">
		ancestors = <"C_PRIMITIVE_OBJECT", ...>
		is_abstract = <True>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Ordered">
			>
		>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				documentation = <"Constraint in the form of a List of Intervals of the parameter type T. Concrete types generated in descendants via template binding.">
				type_def = <
					container_type = <"List">
					type_def = (P_BMM_GENERIC_TYPE) <
						generic_parameters = <"T", ...>
						root_type = <"Interval">
					>
				>
				cardinality = <|>=0|>
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY_OPEN) <
				name = <"default_value">
				documentation = <"Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.">
				type = <"T">
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY_OPEN) <
				name = <"assumed_value">
				documentation = <"Value to be assumed if none sent in data.">
				type = <"T">
			>
		>
		functions = <
			["any_allowed"] = <
				name = <"any_allowed">
				documentation = <"True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result = constraint.is_empty">
				>
			>
			["c_value_conforms_to"] = <
				name = <"c_value_conforms_to">
				documentation = <"True if `_other.any_allowed_` or else for every constraint in the `_constraint_` list there is a constraint in `_other.constraint_` that contains it.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_ORDERED">
					>
				>
			>
			["c_value_congruent_to"] = <
				name = <"c_value_congruent_to">
				documentation = <"True if the items in `_constraint_` are equal in number and identical pair-wise with those in `_other.constraint_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_ORDERED">
					>
				>
			>
		>
	>
	["C_TERMINOLOGY_CODE"] = <
		name = <"C_TERMINOLOGY_CODE">
		documentation = <"Constrainer type for instances of `Terminology_code`. The constraint attribute can contain:

* a single at-code
* a single ac-code, representing a value-set that is defined in the archetype terminology

If there is an assumed value for the ac-code case above, the `_assumed_value_` attribute contains a single at-code, which must come from the list of at-codes defined as the internal value set for the ac-code.

The `_constraint_status_` attribute and `_constraint_required_()` function together define whether the `_constraint_` is considered formal ('required') or not. In the non-required cases, a data-item matched to this constraint may be any coded term.">
		ancestors = <"C_PRIMITIVE_OBJECT", ...>
		properties = <
			["constraint"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"constraint">
				documentation = <"Type of individual constraint - a single string that can either be a local at-code, or a local ac-code signifying a locally defined value set. If an ac-code, assumed_value may contain an at-code from the value set of the ac-code.

Use an empty string for no constraint.">
				is_mandatory = <True>
				type = <"String">
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				documentation = <"Assumed Terminology code value.">
				type = <"Terminology_code">
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				type = <"Terminology_code">
			>
			["constraint_status"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"constraint_status">
				documentation = <"Constraint status of this terminology constraint. If Void, the meaning is as follows:

* in a top-level  archetype, equivalent to `required`;
* in a specialised (source) archetype, the meaning is to inherit the value from the corresponding node in the parent.

In the case of a specialised archetype generated by flattening, the value of this field will be:

* Void if it was Void in the parent;
* otherwise, it will carry the same value as in the parent.">
				type = <"CONSTRAINT_STATUS">
			>
		>
		functions = <
			["constraint_required"] = <
				name = <"constraint_required">
				documentation = <"True if `_constraint_status_` is defined and equals `required` OR if Void. I.e. in archetypes where `C_TERMINOLOGY_CODE` instances have no `_constraint_status_`, the `required` status is assumed, which applies to all legacy archetypes.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["effective_constraint_status"] = <
				name = <"effective_constraint_status">
				documentation = <"Return the effective integer value of the `_constraint_status_` field if it exists. If it is null, return 0, i.e. `required`.

NOTE: the above logic applies to any `C_TERMINOLOGY_NODE` instance in a specialised archetype that redefines another such instance in the flat parent. I.e. no stated `_constraint_status_` means `required`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["value_set_expanded"] = <
				name = <"value_set_expanded">
				documentation = <"Effective set of at-code values corresponding to an ac-code for a locally defined value set. Not defined for ac-codes that have no local value set.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				is_nullable = <True>
			>
			["value_set_substituted"] = <
				name = <"value_set_substituted">
				documentation = <"For locally defined value sets within individual code bindings: return the term URI(s) substituted from bindings for local at-codes in `_value_set_expanded_`.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"Uri">
				>
				is_nullable = <True>
			>
			["value_set_resolved"] = <
				name = <"value_set_resolved">
				documentation = <"For locally defined value sets within individual code bindings: final set of external codes to which value set is resolved.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"Terminology_code">
				>
				is_nullable = <True>
			>
			["valid_value"] = <
				name = <"valid_value">
				documentation = <"True if a `_value_` is valid with respect to constraint expressed in concrete instance of this type. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_value"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_value">
						type = <"Terminology_code">
					>
				>
			>
			["prototype_value"] = <
				name = <"prototype_value">
				documentation = <"A generated prototype value from this constraint object.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Terminology_code">
				>
			>
			["any_allowed"] = <
				name = <"any_allowed">
				documentation = <"True if `_constraint_` is empty.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result := constraint.is_empty">
				>
			>
			["c_value_conforms_to"] = <
				name = <"c_value_conforms_to">
				documentation = <"True if `_other.any_allowed_` or else every constraint in the `_constraint_` list exists in the `_other.constraint_`, and `_effective_constraint_status()_` is <= `_other.effective_constraint_status()_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_TERMINOLOGY_CODE">
					>
				>
			>
			["c_value_congruent_to"] = <
				name = <"c_value_congruent_to">
				documentation = <"True if `_constraint_` and `_other.constraint_` are both value-set ids, and expand to identical value sets, or else are identical value codes; and `_effective_constraint_status()_` = `_other.effective_constraint_status()_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_TERMINOLOGY_CODE">
					>
				>
			>
		>
	>
	["C_TEMPORAL"] = <
		name = <"C_TEMPORAL">
		documentation = <"Purpose Abstract parent of `C_ORDERED` types whose base type is an ISO date/time type.">
		ancestors = <"C_ORDERED", ...>
		is_abstract = <True>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Temporal">
			>
		>
		properties = <
			["pattern_constraint"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"pattern_constraint">
				documentation = <"Optional alternative constraint in the form of a pattern based on ISO8601. See descendants for details.">
				type = <"String">
			>
		>
		functions = <
			["valid_pattern_constraint"] = <
				name = <"valid_pattern_constraint">
				documentation = <"True if `_a_pattern_` is a valid constraint. Define in concrete descendants.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_pattern">
						type = <"String">
					>
				>
			>
			["valid_pattern_constraint_replacement"] = <
				name = <"valid_pattern_constraint_replacement">
				documentation = <"Return True if `_a_pattern_` can be replaced by `_an_other_pattern_` in a specialised constraint. Define in concrete subtypes.">
				is_abstract = <True>
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_pattern">
						type = <"String">
					>
					["an_other_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"an_other_pattern">
						type = <"String">
					>
				>
			>
			["any_allowed"] = <
				name = <"any_allowed">
				documentation = <"True if any value (i.e. instance) of the reference model type would be allowed. Redefined in descendants.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				post_conditions = <
					["Post"] = <"Result = precursor and pattern_constraint.is_empty">
				>
			>
			["c_value_conforms_to"] = <
				name = <"c_value_conforms_to">
				documentation = <"True if `precursor()` or else `_other.pattern_constraint_` is empty, or else `_pattern_constraint_` is a valid (narrower) replacement for `_other.pattern_constraint_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_ORDERED">
					>
				>
			>
			["c_value_congruent_to"] = <
				name = <"c_value_congruent_to">
				documentation = <"True if `precursor (other)` and `_pattern_constraint_ ~ _other.pattern_constraint_`, i.e. either both `Void` or else both non-`Void` and identical.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["other"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other">
						type = <"C_ORDERED">
					>
				>
			>
		>
	>
	["C_TIME"] = <
		name = <"C_TIME">
		documentation = <"Constraint on instances representing times in the form either of a set of validity values, or else time ranges based on the `C_ORDERED` list constraint. 

There is no validity flag for `_hour_`, since it must always be by definition mandatory in order to have a sensible time at all. Syntax expressions of instances of this class include `\"HH:??:xx\"` (time with optional minutes and seconds not allowed).">
		ancestors = <"C_TEMPORAL", ...>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				documentation = <"Formal constraint on the assumed primitive `Iso8601_time` type, in the form of one or more `Interval<Iso8601_time>`.

For a pattern constraint or no constraint, use an empty list.">
				type_def = <
					container_type = <"List">
					type_def = (P_BMM_GENERIC_TYPE) <
						generic_parameters = <"Iso8601_time", ...>
						root_type = <"Interval">
					>
				>
				cardinality = <|>=0|>
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				documentation = <"Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.">
				type = <"Iso8601_time">
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				documentation = <"Value to be assumed if none sent in data.">
				type = <"Iso8601_time">
			>
		>
		functions = <
			["minute_validity"] = <
				name = <"minute_validity">
				documentation = <"Validity of minute in constrained time.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
			["second_validity"] = <
				name = <"second_validity">
				documentation = <"Validity of second in constrained time.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
			["millisecond_validity"] = <
				name = <"millisecond_validity">
				documentation = <"Validity of millisecond in constrained time.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
			["timezone_validity"] = <
				name = <"timezone_validity">
				documentation = <"Validity of timezone in constrained time.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
			["valid_pattern_constraint"] = <
				name = <"valid_pattern_constraint">
				documentation = <"Return `valid_iso8601_time_constraint_pattern (a_pattern)` ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_pattern">
						type = <"String">
					>
				>
			>
			["valid_pattern_constraint_replacement"] = <
				name = <"valid_pattern_constraint_replacement">
				documentation = <"Return `valid_time_constraint_replacements.has(an_other_pattern.as_upper) and then 
valid_time_constraint_replacements.item (an_other_pattern.as_upper).has (a_pattern.as_upper)`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_pattern">
						type = <"String">
					>
					["an_other_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"an_other_pattern">
						type = <"String">
					>
				>
			>
		>
		invariants = <
			["Pattern_validity"] = <"pattern /= Void implies valid_iso8601_time_constraint_pattern (pattern)">
		>
	>
	["C_DATE"] = <
		name = <"C_DATE">
		documentation = <"Constraint on instances representing dates in the form either of a set of validity values, or else date ranges based on the `C_ORDERED` list constraint. 

There is no validity flag for `_year_`, since it must always be by definition mandatory in order to have a sensible date at all. Syntax expressions of instances of this class include `\"YYYY-??-??\"` (date with optional month and day).">
		ancestors = <"C_TEMPORAL", ...>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				documentation = <"Formal constraint on the assumed primitive `Iso8601_date` type, in the form of one or more `Interval<Iso8601_date>`.

For a pattern constraint or no constraint, use an empty list.">
				type_def = <
					container_type = <"List">
					type_def = (P_BMM_GENERIC_TYPE) <
						generic_parameters = <"Iso8601_date", ...>
						root_type = <"Interval">
					>
				>
				cardinality = <|>=0|>
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				documentation = <"Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.">
				type = <"Iso8601_date">
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				documentation = <"Value to be assumed if none sent in data.">
				type = <"Iso8601_date">
			>
		>
		functions = <
			["month_validity"] = <
				name = <"month_validity">
				documentation = <"Validity of month in constrained date.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
			["day_validity"] = <
				name = <"day_validity">
				documentation = <"Validity of day in constrained date.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
			["valid_pattern_constraint"] = <
				name = <"valid_pattern_constraint">
				documentation = <"Return `valid_iso8601_date_constraint_pattern (a_pattern)` ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_pattern">
						type = <"String">
					>
				>
			>
			["valid_pattern_constraint_replacement"] = <
				name = <"valid_pattern_constraint_replacement">
				documentation = <"Return `valid_date_constraint_replacements.has(an_other_pattern.as_upper) and then 
valid_date_constraint_replacements.item (an_other_pattern.as_upper).has (a_pattern.as_upper)`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_pattern">
						type = <"String">
					>
					["an_other_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"an_other_pattern">
						type = <"String">
					>
				>
			>
		>
		invariants = <
			["Pattern_validity"] = <"pattern /= Void implies valid_iso8601_date_constraint_pattern(pattern)">
		>
	>
	["C_DATE_TIME"] = <
		name = <"C_DATE_TIME">
		documentation = <"Constraint on instances representing date/times, i.e. instants in time.

There is no validity flag for `_year_`, since it must always be by definition mandatory in order to have a sensible date/time at all. Syntax expressions of instances of this class include `\"YYYY-MM-DDT??:??:??\"` (date/time with optional time) and `\"YYYY-MMDDTHH:MM:xx\"` (date/time, seconds not allowed).">
		ancestors = <"C_TEMPORAL", ...>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				documentation = <"Formal constraint on the assumed primitive `Iso8601_date_time` type, in the form of one or more `Interval<Iso8601_date_time>`.

For a pattern constraint or no constraint, use an empty list.">
				type_def = <
					container_type = <"List">
					type_def = (P_BMM_GENERIC_TYPE) <
						generic_parameters = <"Iso8601_date_time", ...>
						root_type = <"Interval">
					>
				>
				cardinality = <|>=0|>
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				documentation = <"Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.">
				type = <"Iso8601_date_time">
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				documentation = <"Value to be assumed if none sent in data.">
				type = <"Iso8601_date_time">
			>
		>
		functions = <
			["valid_pattern_constraint"] = <
				name = <"valid_pattern_constraint">
				documentation = <"Return `valid_iso8601_date_time_constraint_pattern (a_pattern)` ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_pattern">
						type = <"String">
					>
				>
			>
			["valid_pattern_constraint_replacement"] = <
				name = <"valid_pattern_constraint_replacement">
				documentation = <"Return `valid_date_time_constraint_replacements.has(an_other_pattern.as_upper) and then 
valid_date_time_constraint_replacements.item (an_other_pattern.as_upper).has (a_pattern.as_upper)`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_pattern">
						type = <"String">
					>
					["an_other_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"an_other_pattern">
						type = <"String">
					>
				>
			>
			["month_validity"] = <
				name = <"month_validity">
				documentation = <"Validity of month in constrained date.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
			["day_validity"] = <
				name = <"day_validity">
				documentation = <"Validity of day in constrained date.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
			["minute_validity"] = <
				name = <"minute_validity">
				documentation = <"Validity of minute in constrained time.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
			["second_validity"] = <
				name = <"second_validity">
				documentation = <"Validity of second in constrained time.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
			["millisecond_validity"] = <
				name = <"millisecond_validity">
				documentation = <"Validity of millisecond in constrained time.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
			["timezone_validity"] = <
				name = <"timezone_validity">
				documentation = <"Validity of timezone in constrained date/time.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"VALIDITY_KIND">
				>
			>
		>
		invariants = <
			["Pattern_validity"] = <"pattern /= Void implies valid_iso8601_date_time_constraint_pattern(pattern)">
		>
	>
	["C_DURATION"] = <
		name = <"C_DURATION">
		documentation = <"Constraint on instances representing duration, which is assumed to have the same parts as the ISO 8601 duration string. Thus, constraints are of the form `\"PWD\"` (weeks and/or days), `\"PDTHMS\"` (days, hours, minutes, seconds) and so on.

Both range and the constraint pattern can be set at the same time, corresponding to the ADL constraint `\"PWD/|P0W..P50W|\"`.

As for all of openEHR, two ISO 8601 exceptions are allowed: 

* the ‘W’ (week) designator can be mixed in - the allowed patterns are: `P[Y|y][M|m][D|d][T[H|h][M|m][S|s]]` and `P[W|w]`;
* the values used in an interval constraint may be negated, i.e. a leading minus (`'-'`) sign may be used.

">
		ancestors = <"C_TEMPORAL", ...>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				documentation = <"Formal constraint on the assumed primitive `Iso8601_duration` type, in the form of one or more `Interval<Iso8601_duration>`.

For a pattern constraint or no constraint, use an empty list.">
				type_def = <
					container_type = <"List">
					type_def = (P_BMM_GENERIC_TYPE) <
						generic_parameters = <"Iso8601_duration", ...>
						root_type = <"Interval">
					>
				>
				cardinality = <|>=0|>
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				documentation = <"Default value set in a template, and present in an operational template. Generally limited to leaf and near-leaf nodes.">
				type = <"Iso8601_duration">
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				documentation = <"Value to be assumed if none sent in data.">
				type = <"Iso8601_duration">
			>
		>
		functions = <
			["years_allowed"] = <
				name = <"years_allowed">
				documentation = <"True if years are allowed in the constrained Duration.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["months_allowed"] = <
				name = <"months_allowed">
				documentation = <"True if months are allowed in the constrained Duration.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["weeks_allowed"] = <
				name = <"weeks_allowed">
				documentation = <"True if weeks are allowed in the constrained Duration.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["days_allowed"] = <
				name = <"days_allowed">
				documentation = <"True if days are allowed in the constrained Duration.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["hours_allowed"] = <
				name = <"hours_allowed">
				documentation = <"True if hours are allowed in the constrained Duration.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["minutes_allowed"] = <
				name = <"minutes_allowed">
				documentation = <"True if minutes are allowed in the constrained Duration.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["seconds_allowed"] = <
				name = <"seconds_allowed">
				documentation = <"True if seconds are allowed in the constrained Duration.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
			>
			["valid_pattern_constraint"] = <
				name = <"valid_pattern_constraint">
				documentation = <"Return `valid_iso8601_duration_constraint_pattern (a_pattern)` ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_pattern">
						type = <"String">
					>
				>
			>
			["valid_pattern_constraint_replacement"] = <
				name = <"valid_pattern_constraint_replacement">
				documentation = <"Return `valid_duration_constraint_replacement (a_pattern, an_other_pattern)`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_pattern">
						type = <"String">
					>
					["an_other_pattern"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"an_other_pattern">
						type = <"String">
					>
				>
			>
		>
	>
	["C_TEMPORAL_DEFINITIONS"] = <
		name = <"C_TEMPORAL_DEFINITIONS">
		documentation = <"Definitions related to `C_TEMPORAL` constraints.">
		properties = <
			["valid_date_constraint_patterns"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"valid_date_constraint_patterns">
				documentation = <"List of allowed date constraints. Contains the values:

```
\"YYYY-MM-DD\"    -- full date required
\"YYYY-MM-??\"    -- day optional
\"YYYY-MM-XX\"    -- day prohibited
\"YYYY-??-??\"    -- any partial or full date
\"YYYY-??-XX\"    -- day prohibited
\"YYYY-XX-XX\"    -- only prohibited
```">
				is_mandatory = <True>
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=1|>
			>
			["valid_date_constraint_replacements"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"valid_date_constraint_replacements">
				documentation = <"List of allowed date constraint replacements e.g. in specialised archetype. Contains the values:

----
\"YYYY-MM-DD\": [],

\"YYYY-MM-??\": [\"YYYY-MM-DD\", 
               \"YYYY-MM-XX\"],

\"YYYY-MM-XX\": [],

\"YYYY-??-??\": [\"YYYY-MM-??\",
               \"YYYY-MM-DD\",
               \"YYYY-MM-XX\",
               \"YYYY-??-XX\",
               \"YYYY-XX-XX\"],

\"YYYY-??-XX\": [\"YYYY-MM-XX\", 
              \"YYYY-XX-XX\"],

\"YYYY-XX-XX\": []
----

In the above, an empty list value indicates no replacements possible.">
				is_mandatory = <True>
				type_def = <
					generic_parameter_defs = <
						["K"] = (P_BMM_SIMPLE_TYPE) <
							type = <"String">
						>
						["V"] = (P_BMM_GENERIC_TYPE) <
							generic_parameters = <"String", ...>
							root_type = <"List">
						>
					>
					root_type = <"Hash">
				>
			>
			["valid_time_constraint_patterns"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"valid_time_constraint_patterns">
				documentation = <"List of allowed time constraints. Contains the values:

```
\"HH:MM:SS\"    -- full time required
\"HH:MM:??\"    -- seconds optional
\"HH:MM:XX\"    -- minutes required, seconds prohibited
\"HH:??:??\"    -- minutes and seconds optional
\"HH:??:XX\"    -- minutes optional, seconds prohibited
```">
				is_mandatory = <True>
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=1|>
			>
			["valid_time_constraint_replacements"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"valid_time_constraint_replacements">
				documentation = <"List of allowed time constraint replacements e.g. in specialised archetype. Contains the values:

----
\"HH:MM:SS\": [],

\"HH:MM:??\": [\"HH:MM:SS\",
             \"HH:MM:XX\"],

\"HH:MM:XX\": [],

\"HH-??-??\": [\"HH:MM:??\",
             \"HH:MM:SS\",
             \"HH:MM:XX\",
             \"HH:??:XX\"],

\"HH-??-XX\": [\"HH:MM:XX\"]
----

In the above, an empty list value indicates no replacements possible.">
				is_mandatory = <True>
				type_def = <
					generic_parameter_defs = <
						["K"] = (P_BMM_SIMPLE_TYPE) <
							type = <"String">
						>
						["V"] = (P_BMM_GENERIC_TYPE) <
							generic_parameters = <"String", ...>
							root_type = <"List">
						>
					>
					root_type = <"Hash">
				>
			>
			["valid_date_time_constraint_patterns"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"valid_date_time_constraint_patterns">
				documentation = <"List of allowed date/time constraints. Contains the values:

```
\"YYYY-MM-DDTHH:MM:SS\"    -- full date/time required
\"YYYY-MM-DDTHH:MM:??\"    -- seconds optional
\"YYYY-MM-DDTHH:MM:XX\"    -- seconds prohibited
\"YYYY-MM-DDTHH:??:??\"    -- minutes and seconds optional
\"YYYY-MM-DDTHH:??:XX\"    -- minutes optional, seconds prohibited
\"YYYY-??-??T??:??:??\"    -- any date/time ok
```">
				is_mandatory = <True>
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=1|>
			>
			["valid_date_time_constraint_replacements"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"valid_date_time_constraint_replacements">
				documentation = <"List of allowed date/time constraint replacements e.g. in specialised archetype. Contains the values:

----
\"YYYY-MM-DDTHH:MM:SS\": [],

\"YYYY-MM-DDTHH:MM:??\": [\"YYYY-MM-DDTHH:MM:SS\",
                        \"YYYY-MM-DDTHH:MM:XX\"],

\"YYYY-MM-DDTHH:MM:XX\": [],

\"YYYY-MM-DDTHH:??:??\": [\"YYYY-MM-DDTHH:??:XX\",
                        \"YYYY-MM-DDTHH:MM:SS\",
                        \"YYYY-MM-DDTHH:MM:??\",
                        \"YYYY-MM-DDTHH:MM:XX\"],

\"YYYY-MM-DDTHH:??:XX\": [\"YYYY-MM-DDTHH:MM:XX\"],

\"YYYY-??-??T??:??:??\": [\"YYYY-MM-DDTHH:MM:SS\",
                        \"YYYY-MM-DDTHH:MM:??\",
                        \"YYYY-MM-DDTHH:MM:XX\",
                        \"YYYY-MM-DDTHH:??:??\",
                        \"YYYY-MM-DDTHH:??:XX\"]
----">
				is_mandatory = <True>
				type_def = <
					generic_parameter_defs = <
						["K"] = (P_BMM_SIMPLE_TYPE) <
							type = <"String">
						>
						["V"] = (P_BMM_GENERIC_TYPE) <
							generic_parameters = <"String", ...>
							root_type = <"List">
						>
					>
					root_type = <"Hash">
				>
			>
		>
		functions = <
			["valid_duration_constraint_replacement"] = <
				name = <"valid_duration_constraint_replacement">
				documentation = <"True if ISO8601 duration string `_other_dur_` contains every character element in `_a_dur_`. For example: 'PYD' (period with year and days only) conforms to 'PYMD', but doesn't conform to 'PY'.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_dur"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_dur">
						type = <"String">
					>
					["other_dur"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"other_dur">
						type = <"String">
					>
				>
			>
			["valid_iso8601_date_constraint_pattern"] = <
				name = <"valid_iso8601_date_constraint_pattern">
				documentation = <"True if string literal like `\"yyyy-MM-dd\"` containing `\"XX\"` or `\"??\"` in `MM` or `dd` slots in pattern constraint is in `_valid_date_constraint_patterns_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["s"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"s">
						type = <"String">
					>
				>
			>
			["valid_iso8601_time_constraint_pattern"] = <
				name = <"valid_iso8601_time_constraint_pattern">
				documentation = <"True if string literal like `\"hh:mm:ss[.ssss]\"` containing `\"XX\"` or `\"??\"` in `mm` or `ss` slots in pattern constraint is in `_valid_time_constraint_patterns_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["s"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"s">
						type = <"String">
					>
				>
			>
			["valid_iso8601_date_time_constraint_pattern"] = <
				name = <"valid_iso8601_date_time_constraint_pattern">
				documentation = <"True if string literal in form `\"yyyy-MM-dd hh:mm:ss[.ssss]\"` containing `\"XX\"` or `\"??\"` in variable slots in pattern constraint is in `_valid_date_time_constraint_patterns_`.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["s"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"s">
						type = <"String">
					>
				>
			>
			["valid_iso8601_duration_constraint_pattern"] = <
				name = <"valid_iso8601_duration_constraint_pattern">
				documentation = <"True if string in form `P[Y|y][M|m][W|w][D|d][T[H|h][M|m][S|s]]` (note: allowing 'W' to be mixed in is an openEHR deviation of ISO 8601).">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["s"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"s">
						type = <"String">
					>
				>
			>
		>
	>
	["CONSTRAINT_STATUS"] = (P_BMM_ENUMERATION_INTEGER) <
		name = <"CONSTRAINT_STATUS">
		documentation = <"Status of `_constraint_`, with values allowing for 'soft' constraints, which are effectively different kinds of suggestions.">
		ancestors = <"Integer", ...>
		item_names = <"required", "extensible", "preferred", "example">
		item_values = <0, 1, 2, 3>
		item_documentations = <"Data item is required to formally satisfy `_constraint_`.

Enumeration value = 0.", "Data item value should satisfy `_constraint_`, i.e. a term in `_constraint_` is to be used if it covers the data item meaning (including more generally); if not, another code may be used, including from another terminology.

Enumeration value = 1.", "Data item value is by preference one of the codes defined by `_constraint_`, but for local reasons may be another code, including from another terminology.

Enumeration value = 2.", "The `_constraint_` code or value-set is considered purely as an example, and the data item may have any value.">
	>
	["ARCHETYPE_TERM"] = <
		name = <"ARCHETYPE_TERM">
		documentation = <"Representation of any coded entity (term or constraint) in the archetype ontology.">
		properties = <
			["code"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"code">
				documentation = <"Code of this term. ">
				is_mandatory = <True>
				type = <"String">
			>
			["text"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"text">
				documentation = <"Short term text, typically for display.">
				is_mandatory = <True>
				type = <"String">
			>
			["description"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"description">
				documentation = <"Full description text.">
				is_mandatory = <True>
				type = <"String">
			>
			["other_items"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"other_items">
				documentation = <"Hash of keys and corresponding values for other items in a term, e.g. provenance.">
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
		>
	>
	["TERMINOLOGY_RELATION"] = <
		name = <"TERMINOLOGY_RELATION">
		documentation = <"Class whose instances represent any kind of 1:N relationship between a source term and 1-N target terms.">
		is_abstract = <True>
		properties = <
			["id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"id">
				documentation = <"Code of source term of this relation.">
				is_mandatory = <True>
				type = <"String">
			>
			["members"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"members">
				documentation = <"List of target terms in this relation.">
				is_mandatory = <True>
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=1|>
			>
		>
	>
	["VALUE_SET"] = <
		name = <"VALUE_SET">
		documentation = <"Representation of a flat value set within the archetype terminology.">
		ancestors = <"TERMINOLOGY_RELATION", ...>
	>
	["ARCHETYPE_TERMINOLOGY"] = <
		name = <"ARCHETYPE_TERMINOLOGY">
		documentation = <"Local terminology of an archetype. This class defines the semantics of the terminology of an archetype.">
		properties = <
			["is_differential"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_differential">
				documentation = <"True if this terminology only contains terms relating to a differential specialisation of the owning artefact, rather than a complete set.">
				is_mandatory = <True>
				type = <"Boolean">
			>
			["original_language"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"original_language">
				documentation = <"Original language of the terminology, as set at artefact creation or parsing time; must be a code in the ISO 639-1 2 character language code-set.
">
				is_mandatory = <True>
				type = <"String">
			>
			["concept_code"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"concept_code">
				documentation = <"Term code defining the meaning of the artefact as a whole, and always used as the id-code on the root node of the artefact. Must be defined in the `_term_definitions_` property.">
				is_mandatory = <True>
				type = <"String">
			>
			["term_definitions"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"term_definitions">
				documentation = <"Directory of term definitions as a two-level table. The outer hash keys are language codes, e.g. `\"en\"`, `\"de\"`, while the inner hash keys are term codes, e.g. `\"id17\"`, `\"at4\"`.">
				is_mandatory = <True>
				type_def = <
					generic_parameter_defs = <
						["K"] = (P_BMM_SIMPLE_TYPE) <
							type = <"String">
						>
						["V"] = (P_BMM_GENERIC_TYPE) <
							generic_parameters = <"String", "ARCHETYPE_TERM">
							root_type = <"Hash">
						>
					>
					root_type = <"Hash">
				>
			>
			["term_bindings"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"term_bindings">
				documentation = <"Directory of bindings to external terminology codes and value sets, as a two-level table. The outer hash keys are terminology ids, e.g. `\"SNOMED_CT\"`, and the inner hash keys are constraint codes, e.g. `\"at4\"`, `\"ac13\"` or paths. The indexed `Uri` objects represent references to externally defined resources, either terms, ontology concepts, or terminology subsets / ref-sets.">
				type_def = <
					generic_parameter_defs = <
						["K"] = (P_BMM_SIMPLE_TYPE) <
							type = <"String">
						>
						["V"] = (P_BMM_GENERIC_TYPE) <
							generic_parameters = <"String", "Uri">
							root_type = <"Hash">
						>
					>
					root_type = <"Hash">
				>
			>
			["owner_archetype"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"owner_archetype">
				documentation = <"Archetype that owns this terminology.">
				is_mandatory = <True>
				type = <"ARCHETYPE">
			>
			["value_sets"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"value_sets">
				documentation = <"Archetype-local value sets, each keyed by value-set id, i.e. an ac-code.">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
			["terminology_extracts"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"terminology_extracts">
				documentation = <"Directory of extracts of external terminologies, as a two-level table. The outer hash keys are terminology ids, e.g. `\"SNOMED_CT\"`, while the inner hash keys are term codes or code-phrases from the relevant terminology, e.g. `\"10094842\"`.">
				type_def = <
					generic_parameter_defs = <
						["K"] = (P_BMM_SIMPLE_TYPE) <
							type = <"String">
						>
						["V"] = (P_BMM_GENERIC_TYPE) <
							generic_parameters = <"String", "ARCHETYPE_TERM">
							root_type = <"Hash">
						>
					>
					root_type = <"Hash">
				>
			>
		>
		functions = <
			["specialisation_depth"] = <
				name = <"specialisation_depth">
				documentation = <"Specialisation depth of this artefact. Unspecialised artefacts have depth 0, with each additional level of specialisation adding 1 to the specialisation_depth.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
			["id_codes"] = <
				name = <"id_codes">
				documentation = <"List of all id codes in the terminology., i.e. the 'id' codes in an ADL archetype, which are the `_node_id_` values on `C_OBJECT` descendants.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["value_codes"] = <
				name = <"value_codes">
				documentation = <"List of all value term codes in the terminology, i.e. the 'at' codes in an ADL archetype, which are used as possible values on terminological constrainer nodes.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				is_nullable = <True>
			>
			["value_set_codes"] = <
				name = <"value_set_codes">
				documentation = <"List of all value set codes in the terminology defining value sets. These correspond to the 'ac' codes in an ADL archetype.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
				is_nullable = <True>
			>
			["has_language"] = <
				name = <"has_language">
				documentation = <"True if language `_a_lang_` is present in archetype terminology. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_lang"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_lang">
						type = <"String">
					>
				>
			>
			["has_terminology"] = <
				name = <"has_terminology">
				documentation = <"True if there are bindings to terminology `_a_terminology_id_` present.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_terminology_id"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_terminology_id">
						type = <"String">
					>
				>
			>
			["has_term_code"] = <
				name = <"has_term_code">
				documentation = <"True if code `_a_code_` defined in this terminology.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_code">
						type = <"String">
					>
				>
			>
			["term_definition"] = <
				name = <"term_definition">
				documentation = <"Term definition for a code, in a specified language. ">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"ARCHETYPE_TERM">
				>
				parameters = <
					["a_lang"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_lang">
						type = <"String">
					>
					["a_code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_code">
						type = <"String">
					>
				>
				pre_conditions = <
					["Pre"] = <"has_term-definition (a_lang, a_code)">
				>
			>
			["term_binding"] = <
				name = <"term_binding">
				documentation = <"Binding of constraint corresponding to `_a_code_` in target external terminology `_a_terminology_id_`, as a string, which is usually a formal query expression.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Uri">
				>
				parameters = <
					["a_terminology"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_terminology">
						type = <"String">
					>
					["a_code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_code">
						type = <"String">
					>
				>
				pre_conditions = <
					["Pre"] = <"has_term_binding (a_terminology_id, a_code)">
				>
			>
			["terminologies_available"] = <
				name = <"terminologies_available">
				documentation = <"List of terminologies to which term or constraint bindings exist in this terminology, computed from bindings.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
			["terminology_extract_term"] = <
				name = <"terminology_extract_term">
				documentation = <"Return an `ARCHETYPE_TERM` from specified terminology extract, for specified term code.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"ARCHETYPE_TERM">
				>
				parameters = <
					["a_terminology_id"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_terminology_id">
						type = <"String">
					>
					["a_code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_code">
						type = <"String">
					>
				>
				pre_conditions = <
					["Pre"] = <"has_terminology_extract (a_terminology_id) and has_terminology_extract_code (a_code)">
				>
			>
			["has_terminology_extract"] = <
				name = <"has_terminology_extract">
				documentation = <"True if there is a provided terminology extract present.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_terminology_id"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_terminology_id">
						type = <"String">
					>
				>
			>
			["languages_available"] = <
				name = <"languages_available">
				documentation = <"List of languages in which terms in this terminology are available.">
				result = (P_BMM_CONTAINER_TYPE) <
					container_type = <"List">
					type = <"String">
				>
			>
		>
		invariants = <
			["Original_language_validity"] = <"code_set (Code_set_id_languages).has_concept_id (original_language)">
			["concept_code_validity"] = <"id_codes.has (concept_code)">
			["Term_bindings_validity"] = <"bindings /= void implies not bindings.is_empty">
			["Parent_archetype_valid"] = <"parent_archetype.terminology = Current">
		>
	>
	["ADL_CODE_DEFINITIONS"] = <
		name = <"ADL_CODE_DEFINITIONS">
		documentation = <"Definitions relating to the internal code system of archetypes.">
		constants = <
			["Id_code_leader"] = <
				name = <"Id_code_leader">
				documentation = <"String leader of ‘identifier’ codes, i.e. codes used to identify archetype nodes.">
				type = <"String">
				value = <"\"id\"">
			>
			["Value_code_leader"] = <
				name = <"Value_code_leader">
				documentation = <"String leader of ‘value’ codes, i.e. codes used to identify codes values, including value set members.">
				type = <"String">
				value = <"\"at\"">
			>
			["Value_set_code_leader"] = <
				name = <"Value_set_code_leader">
				documentation = <"String leader of ‘value set’ codes, i.e. codes used to identify value sets.">
				type = <"String">
				value = <"\"ac\"">
			>
			["Specialisation_separator"] = <
				name = <"Specialisation_separator">
				documentation = <"Character used to separate numeric parts of codes belonging to different specialisation levels.">
				type = <"Character">
				value = <"'.'">
			>
			["Code_regex_pattern"] = <
				name = <"Code_regex_pattern">
				documentation = <"Regex used to define the legal numeric part of any archetype code. Corresponds to the simple pattern of dotted numbers, as used in typical multi-level numbering schemes.">
				type = <"String">
				value = <"\"(0|[1-9][0-9]*)(\\.(0|[1-9][0-9]*))*\"">
			>
			["Root_code_regex_pattern"] = <
				name = <"Root_code_regex_pattern">
				documentation = <"Regex pattern of the root id code of any archetype. Corresponds to codes of the form `id1`, `id1.1`, `id1.1.1` etc..">
				type = <"String">
				value = <"\"^id1(\\.1)*$\"">
			>
			["Primitive_node_id"] = <
				name = <"Primitive_node_id">
				documentation = <"Code id used for `C_PRIMITIVE_OBJECT` nodes on creation.">
				type = <"String">
				value = <"\"id9999\"">
			>
		>
		functions = <
			["codes_conformant"] = <
				name = <"codes_conformant">
				documentation = <"True if `_a_child_code_` conforms to `_a_parent_code_` in the sense of specialisation, i.e. is `_a_child_code_` the same as or more specialised than `_a_parent_code_`?">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_child_code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_child_code">
						type = <"String">
					>
					["a_parent_code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_parent_code">
						type = <"String">
					>
				>
			>
			["is_adl_code"] = <
				name = <"is_adl_code">
				documentation = <"True if `_a_code_` is any kind of ADL archetype local code.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_code">
						type = <"String">
					>
				>
				post_conditions = <
					["Post"] = <"Result = is_id_code (a_code) or else is_value_code (a_code) or else is_value_set_code (a_code)">
				>
			>
			["is_id_code"] = <
				name = <"is_id_code">
				documentation = <"True if `_a_code_` is an 'id' code.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_code">
						type = <"String">
					>
				>
				post_conditions = <
					["Post"] = <"Result = a_code.starts_with (Id_code_leader)">
				>
			>
			["is_value_code"] = <
				name = <"is_value_code">
				documentation = <"True if `_a_code_` is an 'at' code, i.e. a code representing a single terminology item.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_code">
						type = <"String">
					>
				>
				post_conditions = <
					["Post"] = <"Result = a_code.starts_with (Value_code_leader)">
				>
			>
			["is_value_set_code"] = <
				name = <"is_value_set_code">
				documentation = <"True if `_a_code_` is an 'ac' code, i.e. a code referring to a terminology value set.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_code">
						type = <"String">
					>
				>
				post_conditions = <
					["Post"] = <"Result = a_code.starts_with (Value_set_code_leader)">
				>
			>
			["is_redefined_code"] = <
				name = <"is_redefined_code">
				documentation = <"A code has been specialised if there is a non-zero code index anywhere above the last index e.g. 

* `at0.0.1` -> False
* `at1.0.1` -> True">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a_code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_code">
						type = <"String">
					>
				>
			>
			["code_exists_at_level"] = <
				name = <"code_exists_at_level">
				documentation = <"Is `_a_code_` valid at level `_a_level_` or less, i.e. if we remove its trailing specialised part corresponding to specialisation below `_a_level_`, and then any trailing '.0' pieces, do we end up with a valid code? If so it means that the code corresponds to a real node from `_a_level_` or higher.">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Boolean">
				>
				parameters = <
					["a-code"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a-code">
						type = <"String">
					>
					["a_level"] = (P_BMM_SINGLE_FUNCTION_PARAMETER) <
						name = <"a_level">
						type = <"Integer">
					>
				>
			>
		>
	>
	["RM_ATTRIBUTE_VISIBILITY"] = <
		name = <"RM_ATTRIBUTE_VISIBILITY">
		documentation = <"Definition of visibility of an RM attribute within a larger archetype structure.">
		properties = <
			["visibility"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"visibility">
				documentation = <"Visibility setting of a non-archetyped RM attribute (RM attributes that are constrained or within the archetyped structure are visible by default).">
				type = <"VISIBILITY_TYPE">
			>
			["alias"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"alias">
				documentation = <"Optional alias for the attribute referenced by the path.">
				type = <"Terminology_code">
			>
		>
		invariants = <
			["Inv_alias_validity"] = <"alias /= Void implies visibility /= Void">
		>
	>
	["RM_OVERLAY"] = <
		name = <"RM_OVERLAY">
		documentation = <"Container object for archetype statements relating to RM attributes, which may be directly on objects constrained within the archetype, or at deeper non-constrained RM paths from an object or the root.">
		properties = <
			["rm_visibility"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"rm_visibility">
				documentation = <"Optional structure in which visibility and aliasing of reference model elements can be specified. Key is path to an RM attribute, which is typically formed from a path to an archetyped node concatenated with a further pure RM attribute path; may also refer to a non-archetyped attribute.">
				type_def = <
					generic_parameters = <"String", "RM_ATTRIBUTE_VISIBILITY">
					root_type = <"Hash">
				>
			>
		>
	>
	["VISIBILITY_TYPE"] = (P_BMM_ENUMERATION_STRING) <
		name = <"VISIBILITY_TYPE">
		documentation = <"Enumeration of visibility settings for model elements.">
		ancestors = <"String", ...>
		item_names = <"hide", "show">
		item_documentations = <"Indicates to a tool to hide the model element to which this marker is attached.", "Indicates to a tool to show the model element to which this marker is attached.">
	>
	["P_ARCHETYPE_CONSTRAINT"] = <
		name = <"P_ARCHETYPE_CONSTRAINT">
		documentation = <"Archetype equivalent to LOCATABLE class in openEHR Common reference model. Defines common constraints for any inheritor of LOCATABLE in any reference model. ">
		is_abstract = <True>
	>
	["P_C_OBJECT"] = <
		name = <"P_C_OBJECT">
		documentation = <"Abstract model of constraint on any kind of object node. ">
		ancestors = <"P_ARCHETYPE_CONSTRAINT", ...>
		is_abstract = <True>
		properties = <
			["rm_type_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_type_name">
				documentation = <"Reference model type that this node corresponds to. ">
				is_mandatory = <True>
				type = <"String">
			>
			["occurrences"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"occurrences">
				documentation = <"Occurrences of this object node in the data, under the owning attribute. Upper limit can only be greater than 1 if owning attribute has a cardinality of more than 1.">
				type = <"String">
			>
			["node_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"node_id">
				documentation = <"Semantic id of this node, used to differentiate sibling nodes of the same type. Each node_id must be defined in the archetype ontology as a term code. 
">
				is_mandatory = <True>
				type = <"String">
			>
			["is_deprecated"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_deprecated">
				type = <"Boolean">
			>
		>
		functions = <
			["specialisation_depth"] = <
				name = <"specialisation_depth">
				result = (P_BMM_SIMPLE_TYPE) <
					type = <"Integer">
				>
			>
		>
	>
	["P_C_ATTRIBUTE"] = <
		name = <"P_C_ATTRIBUTE">
		documentation = <"Abstract model of constraint on any kind of attribute node.">
		ancestors = <"P_ARCHETYPE_CONSTRAINT", ...>
		properties = <
			["rm_attribute_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_attribute_name">
				documentation = <"Reference model attribute within the enclosing type represented by a C_OBJECT.">
				is_mandatory = <True>
				type = <"String">
			>
			["existence"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"existence">
				documentation = <"Constraint on every attribute, regardless of whether it is singular or of a container type, which indicates whether its target object exists or not (i.e. is mandatory or not).">
				type = <"String">
			>
			["children"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"children">
				documentation = <"Child C_OBJECT nodes. Each such node represents a constraint on the type of this attribute in its reference model. Multiples occur both for multiple items in the case of container attributes, and alternatives in the case of singular attributes. ">
				type_def = <
					container_type = <"List">
					type = <"P_C_OBJECT">
				>
				cardinality = <|>=0|>
			>
			["differential_path"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"differential_path">
				documentation = <"Within a differential specialised archetype, may be set to represent a deep path within the structure to which this constraint and its child constraints apply.">
				type = <"String">
			>
			["cardinality"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"cardinality">
				documentation = <"Cardinality constraint of attribute, if a container attribute.">
				type = <"String">
			>
			["is_multiple"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_multiple">
				documentation = <"Flag indicating whether this attribute constraint is on a container (i.e. multiply-valued) attribute.">
				is_mandatory = <True>
				type = <"Boolean">
			>
		>
	>
	["P_C_DEFINED_OBJECT"] = <
		name = <"P_C_DEFINED_OBJECT">
		documentation = <"Abstract parent type of C_OBJECT subtypes that are defined by value, i.e. whose definitions are actually in the archetype rather than being by reference. ">
		ancestors = <"P_C_OBJECT", ...>
		is_abstract = <True>
		properties = <
			["is_frozen"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_frozen">
				type = <"Boolean">
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				is_mandatory = <True>
				type = <"Any">
			>
		>
	>
	["P_C_COMPLEX_OBJECT_PROXY"] = <
		name = <"P_C_COMPLEX_OBJECT_PROXY">
		documentation = <"A constraint defined by proxy, using a reference to an object constraint defined elsewhere in the same archetype. Note that since this object refers to another node, there are two objects with available occurrences values. The local occurrences value on a COJMPLEX_OBJECT_PROXY should always be used; when setting this from a seri- alised form, if no occurrences is mentioned, the target occurrences should be used (not the standard default of {1..1}); otherwise the locally specified occurrences should be used as normal. When serialising out, if the occurrences is the same as that of the target, it can be left out. ">
		ancestors = <"P_C_OBJECT", ...>
		properties = <
			["target_path"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"target_path">
				documentation = <"Reference to an object node using archetype path notation.">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["P_ARCHETYPE_SLOT"] = <
		name = <"P_ARCHETYPE_SLOT">
		documentation = <"Constraint describing a  slot' where another archetype can occur. ">
		ancestors = <"P_C_OBJECT", ...>
		properties = <
			["includes"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"includes">
				documentation = <"List of constraints defining other archetypes that could be included at this point. ">
				type_def = <
					container_type = <"List">
				>
				cardinality = <|>=0|>
			>
			["excludes"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"excludes">
				documentation = <"List of constraints defining other archetypes that cannot be included at this point. ">
				type_def = <
					container_type = <"List">
				>
				cardinality = <|>=0|>
			>
			["is_closed"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_closed">
				is_mandatory = <True>
				type = <"Boolean">
			>
		>
	>
	["P_C_PRIMITIVE_OBJECT"] = <
		name = <"P_C_PRIMITIVE_OBJECT">
		documentation = <"Parent of types representing constraints on primitive types.">
		ancestors = <"P_C_DEFINED_OBJECT", ...>
		is_abstract = <True>
		properties = <
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				documentation = <"Value to be assumed if none sent in data.">
				type = <"Any">
			>
			["is_enumerated_type_constraint"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_enumerated_type_constraint">
				documentation = <"True if this constraint is actually of an enumerated type that conforms to a primitive type, not a primitive.">
				type = <"Boolean">
			>
			["constraint"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"constraint">
				documentation = <"Constraint represented by this object; redefine in descendants.">
				is_mandatory = <True>
				type = <"Any">
			>
		>
	>
	["P_C_COMPLEX_OBJECT"] = <
		name = <"P_C_COMPLEX_OBJECT">
		documentation = <"Constraint on complex objects, i.e. any object that consists of other object constraints.">
		ancestors = <"P_C_DEFINED_OBJECT", ...>
		properties = <
			["attributes"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"attributes">
				documentation = <"List of constraints on attributes of the reference model type represented by this object.">
				type_def = <
					container_type = <"List">
					type = <"P_C_ATTRIBUTE">
				>
				cardinality = <|>=0|>
			>
			["attribute_tuples"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"attribute_tuples">
				documentation = <"List of attribute tuple constraints under this object constraint, if any.">
				type_def = <
					container_type = <"List">
					type = <"P_C_ATTRIBUTE_TUPLE">
				>
				cardinality = <|>=0|>
			>
		>
	>
	["P_C_ATTRIBUTE_TUPLE"] = <
		name = <"P_C_ATTRIBUTE_TUPLE">
		documentation = <"Object representing a constraint on an atttribute tuple, i.e. a group of attributes that are constrained together. Typically used for representing co-varying constraints like {units, range} constraints.">
		properties = <
			["members"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"members">
				documentation = <"Member attribute constraint objects.">
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=0|>
			>
		>
	>
	["P_C_ARCHETYPE_ROOT"] = <
		name = <"P_C_ARCHETYPE_ROOT">
		ancestors = <"P_C_COMPLEX_OBJECT", ...>
		properties = <
			["archetype_ref"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"archetype_ref">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["P_C_BOOLEAN"] = <
		name = <"P_C_BOOLEAN">
		documentation = <"Constraint on instances of Boolean. Both attributes cannot be set to False, since this would mean that the Boolean value being constrained cannot be True or False.">
		ancestors = <"P_C_PRIMITIVE_OBJECT", ...>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				type_def = <
					container_type = <"List">
					type = <"Boolean">
				>
				cardinality = <|>=0|>
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				type = <"Boolean">
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				is_mandatory = <True>
				type = <"Boolean">
			>
		>
	>
	["P_C_STRING"] = <
		name = <"P_C_STRING">
		documentation = <"Constraint on instances of STRING. ">
		ancestors = <"P_C_PRIMITIVE_OBJECT", ...>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				documentation = <"String constraint - a list of literal strings and / or regular expression strings delimited by the ‘/’ character.">
				is_mandatory = <True>
				type_def = <
					container_type = <"List">
					type = <"String">
				>
				cardinality = <|>=1|>
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				is_mandatory = <True>
				type = <"String">
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				type = <"String">
			>
		>
	>
	["P_C_INTEGER"] = <
		name = <"P_C_INTEGER">
		documentation = <"Constraint on instances of Integer.">
	>
	["P_C_REAL"] = <
		name = <"P_C_REAL">
		documentation = <"Constraint on instances of Real.">
	>
	["P_C_ORDERED"] = <
		name = <"P_C_ORDERED">
		documentation = <"Abstract parent of primitive constrainer classes based on ORDERED base types, i.e. types like Integer, Real, and the Date/Time types. The model constraint is a List of Intervals, which may include point Intervals, and acts as a efficient and formally tractable representation of any number of point values and/or contiguous intervals of an ordered value domain.

In its simplest form, the constraint accessor returns just a single point Interval<T> object, representing a single value.

The next simplest form is a single proper Interval <T> (i.e. normal two-sided or half-open interval). The most complex form is a list of any combination of point and proper intervals.">
		ancestors = <"P_C_PRIMITIVE_OBJECT", ...>
		is_abstract = <True>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Ordered">
			>
		>
		properties = <
			["constraint"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"constraint">
				is_mandatory = <True>
				type_def = <
					container_type = <"List">
					type_def = (P_BMM_GENERIC_TYPE) <
						generic_parameters = <"T", ...>
						root_type = <"Interval">
					>
				>
				cardinality = <|>=1|>
			>
		>
	>
	["P_C_TERMINOLOGY_CODE"] = <
		name = <"P_C_TERMINOLOGY_CODE">
		documentation = <"Constrainer type for instances of TERMINOLOGY_CODE. The primary expression of the constraint is in the property `tuple_constraint', and comes in 3 variations:
* a single at-code
* a single ac-code, representing a value-set that is defined in the archetype terminology
* a list of at- and/or ac-codes, representing the possibilities of a tuple constraint
The last possibility above is enabled by the merge_tuple routine, which enables the constraint of another single-valued C_TERMINOLOGY_CODE to be merged with the current one.">
		ancestors = <"P_C_PRIMITIVE_OBJECT", ...>
		properties = <
			["constraint"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"constraint">
				is_mandatory = <True>
				type = <"String">
			>
			["assumed_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"assumed_value">
				type = <"Terminology_code">
			>
			["default_value"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"default_value">
				is_mandatory = <True>
				type = <"Terminology_code">
			>
		>
	>
	["P_C_TEMPORAL"] = <
		name = <"P_C_TEMPORAL">
		documentation = <"Purpose Abstract parent of C_ORDERED types whose base type is an ISO date/time type.">
		ancestors = <"P_C_ORDERED", ...>
		is_abstract = <True>
		generic_parameter_defs = <
			["T"] = <
				name = <"T">
				conforms_to_type = <"Temporal">
			>
		>
		properties = <
			["pattern_constraint"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"pattern_constraint">
				documentation = <"Optional alternative constraint in the form of a pattern based on ISO8601. See descendants for details.">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["P_C_TIME"] = <
		name = <"P_C_TIME">
		documentation = <"ISO 8601-compatible constraint on instances of Time in the form either of a set of validity values, or else date ranges based on the C_ORDERED list constraint. There is no validity flag for ‘hour’, since it must always be by definition mandatory in order to have a sensible time at all. Syntax expressions of instances of this class include “HH:??:xx” (time with optional minutes and seconds not allowed).">
	>
	["P_C_DATE"] = <
		name = <"P_C_DATE">
		documentation = <"ISO 8601-compatible constraint on instances of Date in the form either of a set of validity values, or else date ranges based on the C_ORDERED list constraint. There is no validity flag for ‘year’, since it must always be by definition mandatory in order to have a sensible date at all. Syntax expressions of instances of this class include “YYYY-??-??” (date with optional month and day).">
	>
	["P_C_DATE_TIME"] = <
		name = <"P_C_DATE_TIME">
		documentation = <"ISO 8601-compatible constraint on instances of Date_Time. There is no validity flag for ‘year’, since it must always be by definition mandatory in order to have a sensible date/time at all. Syntax expressions of instances of this class include “YYYY-MM-DDT??:??:??” (date/time with optional time) and “YYYY-MMDDTHH:MM:xx” (date/time, seconds not allowed).">
	>
	["P_C_DURATION"] = <
		name = <"P_C_DURATION">
	>
	["P_ARCHETYPE"] = <
		name = <"P_ARCHETYPE">
		documentation = <"Archetype equivalent to ARCHETYPED class in Common reference model. Defines semantics of identfication, lifecycle, versioning, composition and specialisation.

An archetype is a modelled as a particular kind of AUTHORED_RESOURCE, and as such, includes descriptive meta-data, language information and revision history. The ARCHETYPE class adds identifying information, a definition - expressed in terms of constraints on instances of an object model, and an ontology.">
		is_abstract = <True>
		properties = <
			["parent_archetype_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"parent_archetype_id">
				documentation = <"Identifier of the specialisation parent of this archetype.">
				type = <"String">
			>
			["archetype_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"archetype_id">
				documentation = <"Identifier of this archetype.">
				is_mandatory = <True>
				type = <"P_ARCHETYPE_HRID">
			>
			["is_differential"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_differential">
				documentation = <"Flag indicating whether this archetype is differential or flat in its contents. Top-level source archetypes have this flag set to True.">
				is_mandatory = <True>
				type = <"Boolean">
			>
			["definition"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"definition">
				documentation = <"Root node of the definition of this archetype.">
				is_mandatory = <True>
				type = <"P_C_COMPLEX_OBJECT">
			>
			["terminology"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"terminology">
				documentation = <"The terminology of the archetype.">
				is_mandatory = <True>
				type = <"P_ARCHETYPE_TERMINOLOGY">
			>
			["rules"] = (P_BMM_CONTAINER_PROPERTY) <
				name = <"rules">
				documentation = <"Rules relating to this archetype. Statements are expressed in first order predicate logic, and usually refer to at least two attributes.">
				type_def = <
					container_type = <"List">
					type = <"EL_BOOLEAN_EXPRESSION">
				>
				cardinality = <|>=0|>
			>
		>
	>
	["P_AUTHORED_ARCHETYPE"] = <
		name = <"P_AUTHORED_ARCHETYPE">
		documentation = <"Root object of a standalone, authored archetype, including all meta-data, description, other identifiers and lifecycle.">
		ancestors = <"P_ARCHETYPE", "AUTHORED_RESOURCE", "P_AUTHORED_RESOURCE">
		properties = <
			["adl_version"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"adl_version">
				documentation = <"ADL version if archteype was read in from an ADL sharable archetype.">
				type = <"String">
			>
			["build_uid"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"build_uid">
				documentation = <"Unique identifier of this archetype artefact instance. A new identifier is assigned every time the content is changed by a tool. Used by tools to distinguish different revisions and/or interim snapshots of the same artefact.">
				is_mandatory = <True>
				type = <"UID">
			>
			["rm_release"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_release">
				documentation = <"Semver.org compatible release of the most recent reference model release on which the archetype in its current version is based. This does not imply conformance only to this release, since an archetype may be valid with respect to multiple releases of a reference model.">
				is_mandatory = <True>
				type = <"String">
			>
			["is_generated"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_generated">
				documentation = <"If True, indicates that this artefact was machine-generated from some other source, in which case, tools would expect to overwrite this artefact on a new generation. Editing tools should set this value to False when a user starts to manually edit an archetype.">
				is_mandatory = <True>
				type = <"Boolean">
			>
			["other_meta_data"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"other_meta_data">
				is_mandatory = <True>
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
		>
	>
	["P_TEMPLATE"] = <
		name = <"P_TEMPLATE">
		documentation = <"Class representing source template, i.e. a kind of archetype that may include template overlays, and may be restricted by tools to only defining mandations, prohibitions, and restrictions on elements already defined in the flat parent.">
		ancestors = <"P_AUTHORED_ARCHETYPE", ...>
	>
	["P_OPERATIONAL_TEMPLATE"] = <
		name = <"P_OPERATIONAL_TEMPLATE">
		documentation = <"Root object of an operational template. An operational template is derived from a TEMPLATE definition and the ARCHETYPEs and/or TEMPLATE_OVERLAYs mentioned by that template by a process of flattening, and potentially removal of unneeded languages and terminologies.

An operational template is used for generating and validating canonical openEHR data, and also as a source artefact for generating other downstream technical artefacts, including XML schemas, APIs and UI form definitions.">
		ancestors = <"P_AUTHORED_ARCHETYPE", ...>
		properties = <
			["component_terminologies"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"component_terminologies">
				documentation = <"Compendium of flattened terminologies of archetypes externally referenced from this archetype, keyed by archetype identifier. This will almost always be present in a template.">
				type_def = <
					generic_parameters = <"String", "P_ARCHETYPE_TERMINOLOGY">
					root_type = <"Hash">
				>
			>
			["terminology_extracts"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"terminology_extracts">
				documentation = <"Directory of term definitions as a two-level  table. The outer hash keys are term codes,  e.g. \"at4\", and the inner hash key are term  attribute names, e.g. \"text\", \"description\" etc.">
				type_def = <
					generic_parameter_defs = <
						["K"] = (P_BMM_SIMPLE_TYPE) <
							type = <"String">
						>
						["V"] = (P_BMM_GENERIC_TYPE) <
							generic_parameters = <"String", "ARCHETYPE_TERM">
							root_type = <"Hash">
						>
					>
					root_type = <"Hash">
				>
			>
		>
	>
	["P_ARCHETYPE_HRID"] = <
		name = <"P_ARCHETYPE_HRID">
		documentation = <"Human_readable identifier (HRID) for an archetype or template.">
		properties = <
			["namespace"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"namespace">
				documentation = <"Reverse domain name namespace identifier.">
				type = <"String">
			>
			["rm_publisher"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_publisher">
				documentation = <"Name of the Reference Model publisher.">
				is_mandatory = <True>
				type = <"String">
			>
			["rm_package"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_package">
				documentation = <"Name of the package in whose reachability graph the rm_class class is found (there can be more than one possibility in many reference models).">
				is_mandatory = <True>
				type = <"String">
			>
			["rm_class"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"rm_class">
				documentation = <"Name of the root class of this archetype.">
				is_mandatory = <True>
				type = <"String">
			>
			["concept_id"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"concept_id">
				documentation = <"The short concept name of the archetype as used in the multi-axial archetype_hrid.">
				is_mandatory = <True>
				type = <"String">
			>
			["release_version"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"release_version">
				documentation = <"The full numeric version of this archetype consisting of 3 parts, e.g. 1.8.2. The archetype_hrid feature includes only the major version.">
				is_mandatory = <True>
				type = <"String">
			>
			["version_status"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"version_status">
				documentation = <"The status of the version, i.e. released, release_candidate etc.">
				is_mandatory = <True>
				type = <"VERSION_STATUS">
			>
			["build_count"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"build_count">
				documentation = <"The build count since last increment of any version part.">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["P_AUTHORED_RESOURCE"] = <
		name = <"P_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 = <"String">
			>
			["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">
			>
			["translations"] = (P_BMM_CONTAINER_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 = <
					container_type = <"List">
					type = <"TRANSLATION_DETAILS">
				>
				cardinality = <|>=0|>
			>
			["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 = <"String">
			>
			["annotations"] = (P_BMM_GENERIC_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_def = <
					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">
				>
			>
		>
	>
	["P_ARCHETYPE_TERMINOLOGY"] = <
		name = <"P_ARCHETYPE_TERMINOLOGY">
		documentation = <"Local ontology of an archetype.">
		properties = <
			["is_differential"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"is_differential">
				is_mandatory = <True>
				type = <"Boolean">
			>
			["original_language"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"original_language">
				is_mandatory = <True>
				type = <"String">
			>
			["term_definitions"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"term_definitions">
				documentation = <"Directory of term definitions as a two-level 
table. The outer hash keys are term codes, 
e.g. \"at0004\", and the inner hash key are term 
attribute names, e.g. \"text\", \"description\" etc.">
				is_mandatory = <True>
				type_def = <
					generic_parameter_defs = <
						["K"] = (P_BMM_SIMPLE_TYPE) <
							type = <"String">
						>
						["V"] = (P_BMM_GENERIC_TYPE) <
							generic_parameters = <"String", "ARCHETYPE_TERM">
							root_type = <"Hash">
						>
					>
					root_type = <"Hash">
				>
			>
			["term_bindings"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"term_bindings">
				documentation = <"Directory of term bindings as a two-level 
table. The outer hash keys are local term codes, 
e.g. \"at0004\", and the inner hash keys are terminology 
code phrases, e.g. \"SNOMED(2003)::163034007\" etc.">
				type_def = <
					generic_parameter_defs = <
						["K"] = (P_BMM_SIMPLE_TYPE) <
							type = <"String">
						>
						["V"] = (P_BMM_GENERIC_TYPE) <
							generic_parameters = <"String", "Uri">
							root_type = <"Hash">
						>
					>
					root_type = <"Hash">
				>
			>
			["value_sets"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"value_sets">
				type_def = <
					generic_parameters = <"String", "VALUE_SET">
					root_type = <"Hash">
				>
			>
		>
	>
	["AOM_PROFILE"] = <
		name = <"AOM_PROFILE">
		documentation = <"Profile of common settings relating to use of reference model(s) and terminology for a given archetype developing organisation.">
		properties = <
			["profile_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"profile_name">
				documentation = <"Name of this profile, usually based on the publisher it pertains to e.g. \"openEHR\", \"CDISC\", etc.">
				is_mandatory = <True>
				type = <"String">
			>
			["archetype_parent_class"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"archetype_parent_class">
				documentation = <"States a class from the Reference Model that provides archetyping capability in RM data structures. This attribute is optional, and there need be no such class in the RM. Defining it here has the effect in tools that the class tree under which archetypes are arranged contains only RM classes inheriting from this class.">
				type = <"String">
			>
			["archetype_data_value_parent_class"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"archetype_data_value_parent_class">
				documentation = <"This attribute defines a base class from the Reference Model whose descendants are considered to be 'logical data types', i.e. of some higher level than the built-in primitive types String, Integer etc. This attribute is optional, even if the RM does have such a class, and is only used to help tooling to provide more intelligent display.">
				type = <"String">
			>
			["aom_rm_type_mappings"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"aom_rm_type_mappings">
				documentation = <"Mappings from AOM built-in types to actual types in RM: whenever the type name is encountered in an archetype, it is mapped to a specific RM type.">
				type_def = <
					generic_parameters = <"String", "AOM_TYPE_MAPPING">
					root_type = <"Hash">
				>
			>
			["archetype_visualise_descendants_of"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"archetype_visualise_descendants_of">
				documentation = <"If `_archetype_parent_class_` is not set, designate a class whose descendants should be made visible in tree and grid renderings of the archetype definition.">
				type = <"String">
			>
			["aom_rm_type_substitutions"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"aom_rm_type_substitutions">
				documentation = <"Allowed type substitutions: Actual RM type names keyed by AOM built-in types which can substitute for them in an archetype. E.g. `<key = \"ISO8601_DATE\", value = \"String\">` means that if RM property `TYPE._some_property_` is of type `String`, an `ISO8601_DATE` is allowed at that position in the archetype.">
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
			["aom_lifecycle_mappings"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"aom_lifecycle_mappings">
				documentation = <"List of mappings of lifecycle state names used in archetypes to AOM lifecycle state names: 

* key = source lifecycle state; 
* value = AOM lifecycle state.">
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
			["rm_primitive_type_equivalences"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"rm_primitive_type_equivalences">
				documentation = <"Equivalences of RM primitive types to in-built set of primitive types. Used to determine which AOM `C_PRIMITIVE_OBJECT` descendant is used for a primitive type. Typical entries:

* `value`	`key`
* \"Real\"	\"Double\"
* \"Integer\"	\"Integer64\"">
				type_def = <
					generic_parameters = <"String", "String">
					root_type = <"Hash">
				>
			>
		>
	>
	["AOM_TYPE_MAPPING"] = <
		name = <"AOM_TYPE_MAPPING">
		documentation = <"Data object expressing a mapping between two types.">
		properties = <
			["source_class_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"source_class_name">
				documentation = <"Name of the AOM type being mapped to an RM type.">
				is_mandatory = <True>
				type = <"String">
			>
			["target_class_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"target_class_name">
				documentation = <"Name of the RM type in the mapping.">
				is_mandatory = <True>
				type = <"String">
			>
			["property_mappings"] = (P_BMM_GENERIC_PROPERTY) <
				name = <"property_mappings">
				documentation = <"List of mappings of properties of this type to another type.">
				type_def = <
					generic_parameters = <"String", "AOM_PROPERTY_MAPPING">
					root_type = <"Hash">
				>
			>
		>
	>
	["AOM_PROPERTY_MAPPING"] = <
		name = <"AOM_PROPERTY_MAPPING">
		documentation = <"Data object expressing a mapping between two class properties.">
		properties = <
			["source_property_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"source_property_name">
				documentation = <"Name of property in source class.">
				is_mandatory = <True>
				type = <"String">
			>
			["target_property_name"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"target_property_name">
				documentation = <"Name of property in target class.">
				is_mandatory = <True>
				type = <"String">
			>
		>
	>
	["EXPR_ARCHETYPE_ID_CONSTRAINT"] = <
		name = <"EXPR_ARCHETYPE_ID_CONSTRAINT">
		documentation = <"Expression tree leaf item representing a constraint on an archetype identifier.">
		ancestors = <"EXPR_CONSTRAINT", ...>
		properties = <
			["item"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"item">
				documentation = <"A C_STRING representing a regular expression for matching Archetype identifiers.">
				is_mandatory = <True>
				type = <"C_STRING">
			>
		>
	>
	["EXPR_ARCHETYPE_REF"] = <
		name = <"EXPR_ARCHETYPE_REF">
		documentation = <"Expression tree leaf item representing a reference to a value found in data at a location specified by a path in the archetype definition.

* A path referring to a value in the archetype (paths with a leading ‘/’ are in the definition section.
* Paths with no leading ‘/’ are in the outer part of the archetype, e.g. “archetype_id/value” refers to the String value of the archetype_id attribute of the enclosing archetype.
">
		ancestors = <"EXPR_VALUE_REF", ...>
		properties = <
			["path"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"path">
				documentation = <"The path to the archetype node.">
				is_mandatory = <True>
				type = <"String">
			>
			["item"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"item">
				is_mandatory = <True>
				type = <"ARCHETYPE_CONSTRAINT">
			>
		>
	>
	["EXPR_CONSTRAINT"] = <
		name = <"EXPR_CONSTRAINT">
		documentation = <"Expression tree leaf item representing a constraint on a primitive type, expressed in the form of a concrete subtype of C_PRIMITIVE_OBJECT.">
		ancestors = <"EXPR_LEAF", ...>
		properties = <
			["item"] = (P_BMM_SINGLE_PROPERTY) <
				name = <"item">
				documentation = <"The constraint.">
				is_mandatory = <True>
				type = <"C_PRIMITIVE_OBJECT">
			>
		>
	>
>