Core Package

{
    "name": "BMM_DEFINITIONS",
    "documentation": "Definitions used by all BMM packages.",
    "ancestors": [
        "BASIC_DEFINITIONS"
    ],
    "constants": {
        "Bmm_internal_version": {
            "name": "Bmm_internal_version",
            "documentation": "Current internal version of BMM meta-model, used to determine if a given schema can be processed by a given implementation of the model.",
            "type": "String"
        },
        "Schema_name_delimiter": {
            "name": "Schema_name_delimiter",
            "documentation": "Delimiter used to separate schema id from package path in a fully qualified path.",
            "type": "String",
            "value": "\"::\""
        },
        "Package_name_delimiter": {
            "name": "Package_name_delimiter",
            "documentation": "Delimiter used to separate package names in a package path.",
            "type": "String",
            "value": "\".\""
        },
        "Bmm_schema_file_extension": {
            "name": "Bmm_schema_file_extension",
            "documentation": "Extension used for BMM files.",
            "type": "String",
            "value": "\".bmm\""
        },
        "Type_delimiter": {
            "name": "Type_delimiter",
            "documentation": "Appears between a name and a type in a declaration or type signature.",
            "type": "Character",
            "value": "':'"
        },
        "Generic_left_delimiter": {
            "name": "Generic_left_delimiter",
            "documentation": "Left delimiter for generic class and generic type names, as used in `List<T>`.",
            "type": "Character",
            "value": "'<'"
        },
        "Generic_right_delimiter": {
            "name": "Generic_right_delimiter",
            "documentation": "Right delimiter for generic class and generic type names, as used in `List<T>`.",
            "type": "Character",
            "value": "'>'"
        },
        "Generic_separator": {
            "name": "Generic_separator",
            "documentation": "Separator used in Generic types.",
            "type": "Character",
            "value": "','"
        },
        "Generic_constraint_delimiter": {
            "name": "Generic_constraint_delimiter",
            "documentation": "Delimiter between formal type parameter and constraint type, as used in `Sortable<T: Ordered>`.",
            "type": "Character",
            "value": "':'"
        },
        "Tuple_left_delim": {
            "name": "Tuple_left_delim",
            "documentation": "Left delimiter of a Tuple type and also instance. Example:\n\n* `[Integer, String]` - a tuple type;\n* `[3, \"Quixote\"]` - a tuple.",
            "type": "Character",
            "value": "'['"
        },
        "Tuple_right_delim": {
            "name": "Tuple_right_delim",
            "documentation": "Right delimiter of a Tuple type and also instance.",
            "type": "Character",
            "value": "']'"
        },
        "Tuple_separator": {
            "name": "Tuple_separator",
            "documentation": "Separator used in Tuple types and instances.",
            "type": "Character",
            "value": "','"
        },
        "Constraint_left_delim": {
            "name": "Constraint_left_delim",
            "documentation": "Left delimiter used in serial form of instance constrained enumeration.",
            "type": "Character",
            "value": "'«'"
        },
        "Constraint_right_delim": {
            "name": "Constraint_right_delim",
            "documentation": "Right delimiter used in serial form of instance constrained enumeration.",
            "type": "Character",
            "value": "'»'"
        },
        "Metadata_bmm_version": {
            "name": "Metadata_bmm_version",
            "documentation": "Attribute name of logical attribute 'bmm_version' in .bmm schema file.",
            "type": "String",
            "value": "\"bmm_version\""
        },
        "Metadata_schema_name": {
            "name": "Metadata_schema_name",
            "documentation": "Attribute name of logical attribute 'schema_name' in .bmm schema file.",
            "type": "String",
            "value": "\"schema_name\""
        },
        "Metadata_rm_publisher": {
            "name": "Metadata_rm_publisher",
            "documentation": "Attribute name of logical attribute 'rm_publisher' in .bmm schema file.",
            "type": "String",
            "value": "\"rm_publisher\""
        },
        "Metadata_rm_release": {
            "name": "Metadata_rm_release",
            "documentation": "Attribute name of logical attribute 'rm_release' in .bmm schema file.",
            "type": "String",
            "value": "\"rm_release\""
        },
        "Metadata_schema_revision": {
            "name": "Metadata_schema_revision",
            "documentation": "Attribute name of logical attribute 'schema_revision' in .bmm schema file.",
            "type": "String",
            "value": "\"schema_revision\""
        },
        "Metadata_schema_lifecycle_state": {
            "name": "Metadata_schema_lifecycle_state",
            "documentation": "Attribute name of logical attribute 'schema_lifecycle_state' in .bmm schema file.",
            "type": "String",
            "value": "\"schema_lifecycle_state\""
        },
        "Metadata_schema_description": {
            "name": "Metadata_schema_description",
            "documentation": "Attribute name of logical attribute 'schema_description' in .bmm schema file.",
            "type": "String",
            "value": "\"schema_description\""
        },
        "Metadata_schema_path": {
            "name": "Metadata_schema_path",
            "documentation": "Path of schema file.",
            "type": "String",
            "value": "\"schema_path\""
        }
    },
    "functions": {
        "Any_class": {
            "name": "Any_class",
            "documentation": "built-in class definition corresponding to the top `Any' class.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_SIMPLE_CLASS"
            }
        },
        "Any_type": {
            "name": "Any_type",
            "documentation": "Built-in type definition corresponding to the top `Any' type.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_SIMPLE_TYPE"
            }
        },
        "create_schema_id": {
            "name": "create_schema_id",
            "documentation": "Create schema id, formed from:\n\n`a_model_publisher '-' a_schema_name '-' a_model_release`\n\ne.g. `openehr_rm_1.0.3`, `openehr_test_1.0.1`, `iso_13606_1_2008_2.1.2`.",
            "parameters": {
                "a_model_publisher": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_model_publisher",
                    "type": "Any"
                },
                "a_schema_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_schema_name",
                    "type": "Any"
                },
                "a_model_release": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_model_release",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        }
    }
}

{
    "name": "BMM_MODEL",
    "documentation": "Definition of the root of a BMM model (along with what is inherited from `BMM_SCHEMA_CORE`).",
    "ancestors": [
        "BMM_PACKAGE_CONTAINER",
        "BMM_MODEL_METADATA"
    ],
    "properties": {
        "class_definitions": {
            "_type": "P_BMM_GENERIC_PROPERTY",
            "name": "class_definitions",
            "documentation": "All classes in this model, keyed by type name.",
            "type_def": {
                "root_type": "Hash",
                "generic_parameters": [
                    "String",
                    "BMM_CLASS"
                ]
            }
        },
        "used_models": {
            "_type": "P_BMM_CONTAINER_PROPERTY",
            "name": "used_models",
            "documentation": "List of other models 'used' (i.e. 'imported' by this model). Classes in the current model may refer to classes in a used model by specifying the other class's `_scope_` meta-attribute.",
            "type_def": {
                "container_type": "List",
                "type": "BMM_MODEL"
            },
            "cardinality": {
                "lower": 0,
                "upper_unbounded": true
            }
        }
    },
    "functions": {
        "model_id": {
            "name": "model_id",
            "documentation": "Identifier of this model, lower-case, formed from:\n\n`<rm_publisher>_<model_name>_<rm_release>`\n\nE.g. `\"openehr_ehr_1.0.4\"`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        },
        "class_definition": {
            "name": "class_definition",
            "documentation": "Retrieve the class definition corresponding to `_a_type_name_` (which may contain a generic part).",
            "parameters": {
                "a_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_name",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_CLASS"
            }
        },
        "type_definition": {
            "name": "type_definition",
            "documentation": "Retrieve the class definition corresponding to `_a_type_name_`. If it contains a generic part, this will be removed if it is a fully open generic name, otherwise it will remain intact, i.e. if it is an effective generic name that identifies a `BMM_GENERIC_CLASS_EFFECTIVE`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_CLASS"
            }
        },
        "has_class_definition": {
            "name": "has_class_definition",
            "documentation": "True if `_a_class_name_` has a class definition in the model.",
            "parameters": {
                "a_class_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_class_name",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "has_type_definition": {
            "name": "has_type_definition",
            "documentation": "True if `_a_type_name_` is already concretely known in the system, including if it is generic, which may be open, partially open or closed.",
            "parameters": {
                "a_type_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_type_name",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "enumeration_definition": {
            "name": "enumeration_definition",
            "documentation": "Retrieve the enumeration definition corresponding to `_a_type_name_`.",
            "parameters": {
                "a_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_name",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_ENUMERATION"
            }
        },
        "primitive_types": {
            "name": "primitive_types",
            "documentation": "List of keys in `_class_definitions_` of items marked as primitive types.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            },
            "is_nullable": true
        },
        "enumeration_types": {
            "name": "enumeration_types",
            "documentation": "List of keys in `_class_definitions_` of items that are enumeration types.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            },
            "is_nullable": true
        },
        "property_definition": {
            "name": "property_definition",
            "documentation": "Retrieve the property definition for `_a_prop_name_` in flattened class corresponding to `_a_type_name_`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_PROPERTY"
            }
        },
        "ms_conformant_property_type": {
            "name": "ms_conformant_property_type",
            "documentation": "True if `_a_ms_property_type_` is a valid 'MS' dynamic type for `_a_property_` in BMM type `_a_bmm_type_name_`. 'MS' conformance means 'model-semantic' conformance, which abstracts away container types like `List<>`, `Set<>` etc and compares the dynamic type with the relation target type in the UML sense, i.e. regardless of whether there is single or multiple containment.",
            "parameters": {
                "a_bmm_type_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_bmm_type_name",
                    "type": "String"
                },
                "a_bmm_property_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_bmm_property_name",
                    "type": "String"
                },
                "a_ms_property_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_ms_property_name",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "property_definition_at_path": {
            "name": "property_definition_at_path",
            "documentation": "Retrieve the property definition for `_a_property_path_` in flattened class corresponding to `_a_type_name_`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_PROPERTY"
            }
        },
        "class_definition_at_path": {
            "name": "class_definition_at_path",
            "documentation": "Retrieve the class definition for the class that owns the terminal attribute in `a_prop_path` in flattened class corresponding to `a_type_name`.",
            "parameters": {
                "a_type_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_type_name",
                    "type": "String"
                },
                "a_prop_path": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_prop_path",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_CLASS"
            }
        },
        "all_ancestor_classes": {
            "name": "all_ancestor_classes",
            "documentation": "Return all ancestor types of `_a_class_name_` up to root class (usually `Any`, `Object` or something similar). Does  not include current class. Returns empty list if none.",
            "parameters": {
                "a_class": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_class",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            },
            "is_nullable": true
        },
        "is_descendant_of": {
            "name": "is_descendant_of",
            "documentation": "True if `_a_class_name_` is a descendant in the model of `_a_parent_class_name_`.",
            "parameters": {
                "a_class_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_class_name",
                    "type": "String"
                },
                "a_parent_class_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_parent_class_name",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "type_conforms_to": {
            "name": "type_conforms_to",
            "documentation": "Check conformance of `_a_desc_type_` to `_an_anc_type_`; the types may be generic, and may contain open generic parameters like 'T' etc. These are replaced with their appropriate constrainer types, or Any during the conformance testing process.\n\nConformance is found if:\n\n* [base class test] types are non-generic, and either type names are identical, or else `_a_desc_type_` has `_an_anc_type_` in its ancestors;\n* both types are generic and pass base class test; number of generic params matches, and each generic parameter type, after 'open parameter' substitution, recursively passes; `_type_name_conforms_to_` test\n* descendant type is generic and ancestor type is not, and they pass base classes test.",
            "parameters": {
                "a_desc_type": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_desc_type",
                    "type": "String"
                },
                "an_anc_type": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "an_anc_type",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "subtypes": {
            "name": "subtypes",
            "documentation": "Generate type substitutions for the supplied type, which may be simple, generic (closed, open or partially open), or a container type. In the generic and container cases, the result is the permutation of the base class type and type substitutions of all generic parameters.",
            "parameters": {
                "a_type": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_type",
                    "documentation": "Name of a type.",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            }
        },
        "any_class_definition": {
            "name": "any_class_definition",
            "documentation": "`BMM_SIMPLE_CLASS` instance for the `Any` class. This may be defined in the BMM schema, but if not, use `BMM_DEFINITIONS._any_class_`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_SIMPLE_CLASS"
            }
        },
        "any_type_definition": {
            "name": "any_type_definition",
            "documentation": "`BMM_SIMPLE_TYPE` instance for the `Any` type.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_SIMPLE_TYPE"
            }
        },
        "boolean_type_definition": {
            "name": "boolean_type_definition",
            "documentation": "`BMM_SIMPLE_TYPE` instance for the `Boolean` type.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_SIMPLE_TYPE"
            }
        }
    },
    "invariants": {
        "Inv_top_level_scope": "scope = self"
    }
}

{
    "name": "BMM_PACKAGE_CONTAINER",
    "documentation": "A BMM model component that contains packages and classes.",
    "is_abstract": true,
    "ancestors": [
        "BMM_DECLARATION"
    ],
    "properties": {
        "packages": {
            "_type": "P_BMM_GENERIC_PROPERTY",
            "name": "packages",
            "documentation": "Child packages; keys all in upper case for guaranteed matching.",
            "type_def": {
                "root_type": "Hash",
                "generic_parameters": [
                    "String",
                    "BMM_PACKAGE"
                ]
            }
        },
        "scope": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "scope",
            "documentation": "Model element within which a referenceable element is known.",
            "is_mandatory": true,
            "type": "BMM_PACKAGE_CONTAINER"
        }
    },
    "functions": {
        "package_at_path": {
            "name": "package_at_path",
            "documentation": "Package at the path `_a_path_`.",
            "parameters": {
                "a_path": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_path",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_PACKAGE"
            },
            "is_nullable": true
        },
        "do_recursive_packages": {
            "name": "do_recursive_packages",
            "documentation": "Recursively execute `_action_`, which is a procedure taking a `BMM_PACKAGE` argument, on all members of packages.",
            "parameters": {
                "action": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "action",
                    "type": "EL_PROCEDURE_AGENT"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "void"
            }
        },
        "has_package_path": {
            "name": "has_package_path",
            "documentation": "True if there is a package at the path `_a_path_`; paths are delimited with delimiter `{BMM_DEFINITIONS}_Package_name_delimiter_`.",
            "parameters": {
                "a_path": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_path",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        }
    }
}

{
    "name": "BMM_PACKAGE",
    "documentation": "Abstraction of a package as a tree structure whose nodes can contain other packages and classes.\n\nThe `_name_` may be qualified if it is a top-level package.",
    "ancestors": [
        "BMM_PACKAGE_CONTAINER"
    ],
    "properties": {
        "classes": {
            "_type": "P_BMM_CONTAINER_PROPERTY",
            "name": "classes",
            "documentation": "Classes listed as being in this package.",
            "type_def": {
                "container_type": "List",
                "type": "BMM_CLASS"
            },
            "cardinality": {
                "lower": 0,
                "upper_unbounded": true
            }
        }
    },
    "functions": {
        "root_classes": {
            "name": "root_classes",
            "documentation": "Obtain the set of top-level classes in this package, either from this package itself or by recursing into the structure until classes are obtained from child packages. Recurse into each child only far enough to find the first level of classes.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "BMM_CLASS"
            },
            "is_nullable": true
        },
        "path": {
            "name": "path",
            "documentation": "Full path of this package back to root package.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        }
    }
}

{
    "name": "BMM_TYPE",
    "documentation": "Abstract idea of specifying a type in some context. This is not the same as 'defining' a class. A type specification is essentially a reference of some kind, that defines the type of an attribute, or function result or argument. It may include generic parameters that might or might not be bound. See subtypes.",
    "is_abstract": true,
    "functions": {
        "type_name": {
            "name": "type_name",
            "documentation": "Formal string form of the type as per UML.",
            "is_abstract": true,
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        },
        "type_signature": {
            "name": "type_signature",
            "documentation": "Signature form of the type name, which for generics includes generic parameter constrainer types E.g. `Interval<T:Ordered>`.\n\nDefaults to the value of `_type_name()_`.\n",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        },
        "is_abstract": {
            "name": "is_abstract",
            "documentation": "If true, indicates an abstract class in a BMM model, or a type based on an abstract class, i.e. a type that cannot be directly instantiated.",
            "is_abstract": true,
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "is_primitive": {
            "name": "is_primitive",
            "documentation": "If True, indicates that the entity in a BMM model is considered to relate to a primitive type set, i.e. be a primitive type, or be a definer of one.",
            "is_abstract": true,
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "unitary_type": {
            "name": "unitary_type",
            "documentation": "Type with any container abstracted away; may be a formal generic type.",
            "is_abstract": true,
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_UNITARY_TYPE"
            }
        },
        "effective_type": {
            "name": "effective_type",
            "documentation": "Type with any container abstracted away, and any formal parameter replaced by its effective constraint type.",
            "is_abstract": true,
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_EFFECTIVE_TYPE"
            }
        },
        "flattened_type_list": {
            "name": "flattened_type_list",
            "documentation": "Completely flattened list of type names, flattening out all generic parameters.",
            "is_abstract": true,
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            }
        }
    }
}

{
    "name": "BMM_CLASS",
    "documentation": "Meta-type corresponding a class definition in an object model. Inheritance is specified by the `_ancestors_` attribute, which contains a list of _types_ rather than classes. Inheritance is thus understood in BMM as a stated relationship between classes. The equivalent relationship between types is conformance.\n\nNOTE: unlike UML, the `_name_` is just the root name, even if the class is generic. Use `_type_name()_` to obtain the qualified type name.",
    "is_abstract": true,
    "ancestors": [
        "BMM_MODULE"
    ],
    "properties": {
        "ancestors": {
            "_type": "P_BMM_CONTAINER_PROPERTY",
            "name": "ancestors",
            "documentation": "List of immediate inheritance parents.",
            "type_def": {
                "container_type": "List",
                "type": "String"
            },
            "cardinality": {
                "lower": 0,
                "upper_unbounded": true
            }
        },
        "package": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "package",
            "documentation": "Package this class belongs to.",
            "is_mandatory": true,
            "type": "BMM_PACKAGE"
        },
        "properties": {
            "_type": "P_BMM_GENERIC_PROPERTY",
            "name": "properties",
            "documentation": "List of attributes defined in this class.",
            "type_def": {
                "root_type": "Hash",
                "generic_parameters": [
                    "String",
                    "BMM_PROPERTY"
                ]
            }
        },
        "source_schema_id": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "source_schema_id",
            "documentation": "Reference to original source schema defining this class. Useful for UI tools to determine which original schema file to open for a given class for manual editing.",
            "is_mandatory": true,
            "type": "String"
        },
        "immediate_descendants": {
            "_type": "P_BMM_CONTAINER_PROPERTY",
            "name": "immediate_descendants",
            "documentation": "List of computed references to base classes of immediate inheritance descendants, derived when members of `_ancestors_` are attached at creation time.",
            "type_def": {
                "container_type": "List",
                "type": "BMM_CLASS"
            },
            "cardinality": {
                "lower": 0,
                "upper_unbounded": true
            }
        },
        "is_override": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "is_override",
            "documentation": "True if this definition overrides a class of the same name in an included schema.",
            "is_mandatory": true,
            "type": "Boolean"
        },
        "constants": {
            "_type": "P_BMM_GENERIC_PROPERTY",
            "name": "constants",
            "documentation": "List of constants defined in this class.",
            "type_def": {
                "root_type": "Hash",
                "generic_parameters": [
                    "String",
                    "BMM_CONSTANT"
                ]
            }
        },
        "functions": {
            "_type": "P_BMM_GENERIC_PROPERTY",
            "name": "functions",
            "documentation": "List of functions defined in this class.",
            "type_def": {
                "root_type": "Hash",
                "generic_parameters": [
                    "String",
                    "BMM_FUNCTION"
                ]
            }
        },
        "procedures": {
            "_type": "P_BMM_GENERIC_PROPERTY",
            "name": "procedures",
            "documentation": "List of procedures defined in this class.",
            "type_def": {
                "root_type": "Hash",
                "generic_parameters": [
                    "String",
                    "BMM_PROCEDURE"
                ]
            }
        },
        "is_primitive": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "is_primitive",
            "documentation": "True if this class represents a type considered to be primitive in the type system, i.e. any typically built-in or standard library type such as `String`, `Date`, `Hash<K,V>` etc.",
            "type": "Boolean",
            "default": false
        },
        "is_abstract": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "is_abstract",
            "documentation": "True if this class is marked as abstract, i.e. direct instances cannot be created from its direct type.",
            "type": "Boolean",
            "default": false
        },
        "invariants": {
            "_type": "P_BMM_CONTAINER_PROPERTY",
            "name": "invariants",
            "type_def": {
                "container_type": "List",
                "type": "BMM_ASSERTION"
            },
            "cardinality": {
                "lower": 0,
                "upper_unbounded": true
            }
        },
        "creators": {
            "_type": "P_BMM_CONTAINER_PROPERTY",
            "name": "creators",
            "documentation": "Subset of `_procedures_` that may be used to initialise a new instance of an object, and whose execution will guarantee that class invariants are satisfied.",
            "type_def": {
                "container_type": "List",
                "type": "String"
            },
            "cardinality": {
                "lower": 0,
                "upper_unbounded": true
            }
        },
        "converters": {
            "_type": "P_BMM_CONTAINER_PROPERTY",
            "name": "converters",
            "documentation": "Subset of `_creators_` that create a new instance from a single argument of another type.",
            "type_def": {
                "container_type": "List",
                "type": "String"
            },
            "cardinality": {
                "lower": 0,
                "upper_unbounded": true
            }
        },
        "feature_groups": {
            "_type": "P_BMM_CONTAINER_PROPERTY",
            "name": "feature_groups",
            "documentation": "List of feature groups in this class.",
            "type_def": {
                "container_type": "List",
                "type": "BMM_FEATURE_GROUP"
            },
            "cardinality": {
                "lower": 0,
                "upper_unbounded": true
            }
        }
    },
    "functions": {
        "type": {
            "name": "type",
            "documentation": "Generate a type object that represents the type for which this class is the definer.",
            "is_abstract": true,
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_MODEL_TYPE"
            }
        },
        "all_ancestors": {
            "name": "all_ancestors",
            "documentation": "List of all inheritance parent class names, recursively.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            },
            "is_nullable": true
        },
        "all_descendants": {
            "name": "all_descendants",
            "documentation": "Compute all descendants by following `_immediate_descendants_`.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            },
            "is_nullable": true
        },
        "suppliers": {
            "name": "suppliers",
            "documentation": "List of names of immediate supplier classes, including concrete generic parameters, concrete descendants of abstract statically defined types, and inherited suppliers. (Where generics are unconstrained, no class name is added, since logically it would be `Any` and this can always be assumed anyway). This list includes primitive types.\n",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            },
            "is_nullable": true
        },
        "suppliers_non_primitive": {
            "name": "suppliers_non_primitive",
            "documentation": "Same as `suppliers` minus primitive types, as defined in input schema.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            },
            "is_nullable": true
        },
        "supplier_closure": {
            "name": "supplier_closure",
            "documentation": "List of names of all classes in full supplier closure, including concrete generic parameters; (where generics are unconstrained, no class name is added, since logically it would be `Any` and this can always be assumed anyway).  This list includes primitive types.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            },
            "is_nullable": true
        },
        "package_path": {
            "name": "package_path",
            "documentation": "Fully qualified package name, of form: `package.package`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        },
        "class_path": {
            "name": "class_path",
            "documentation": "Fully qualified class name, of form: `package.package.CLASS` with package path in lower-case and class in original case.\n",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        },
        "is_primitive": {
            "name": "is_primitive",
            "documentation": "True if this class is designated a primitive type within the overall type system of the schema. Set from schema.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "is_abstract": {
            "name": "is_abstract",
            "documentation": "True if this class is abstract in its model. Value provided from an underlying data property set at creation or construction time.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "features": {
            "name": "features",
            "documentation": "List of all feature definitions introduced in this class.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "BMM_CLASS_FEATURE"
            },
            "is_nullable": true
        },
        "flat_features": {
            "name": "flat_features",
            "documentation": "Consolidated list of all feature definitions from this class and all inheritance ancestors.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "BMM_CLASS_FEATURE"
            },
            "is_nullable": true
        },
        "flat_properties": {
            "name": "flat_properties",
            "documentation": "List of all properties due to current and ancestor classes, keyed by property name.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "BMM_PROPERTY"
            },
            "is_nullable": true
        }
    },
    "invariants": {
        "Inv_constructors": "for_all p in creators : procedures.has(p)",
        "Inv_converters": "for_all p in converters : creators.has(p) and p.arity() = 1"
    }
}

{
    "name": "BMM_PROPERTY",
    "documentation": "Meta-type of a property definition within a class definition of an object model. The `_is_composition_` attribute indicates whether the property has sub-part or an association semantics with respect to the owning class.",
    "is_abstract": true,
    "ancestors": [
        "BMM_INSTANTIABLE",
        "BMM_CLASS_FEATURE"
    ],
    "properties": {
        "is_im_runtime": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "is_im_runtime",
            "documentation": "True if this property is marked with info model `_im_runtime_` property.",
            "type": "Boolean",
            "default": false
        },
        "is_im_infrastructure": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "is_im_infrastructure",
            "documentation": "True if this property was marked with info model `_im_infrastructure_` flag.",
            "type": "Boolean",
            "default": false
        },
        "is_composition": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "is_composition",
            "documentation": "True if this property instance is a compositional sub-part of the owning class instance. Equivalent to 'composition' in UML associations (but missing from UML properties without associations) and also 'cascade-delete' semantics in ER schemas.",
            "type": "Boolean",
            "default": false
        }
    },
    "functions": {
        "existence": {
            "name": "existence",
            "documentation": "Interval form of `0..1`, `1..1` etc, derived from `_is_nullable_`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Multiplicity_interval"
            }
        },
        "display_name": {
            "name": "display_name",
            "documentation": "Name of this property to display in UI.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        }
    },
    "invariants": {
        "Inv_signature_no_args": "signature.arguments = Void"
    }
}

{
    "name": "BMM_CONTAINER_PROPERTY",
    "documentation": "Meta-type of for properties of linear container type, such as List<T> etc.",
    "ancestors": [
        "BMM_PROPERTY"
    ],
    "properties": {
        "cardinality": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "cardinality",
            "documentation": "Cardinality of this container.",
            "type": "Multiplicity_interval"
        },
        "type": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "type",
            "documentation": "Declared or inferred static type of the entity.",
            "is_mandatory": true,
            "type": "BMM_CONTAINER_TYPE"
        }
    },
    "functions": {
        "display_name": {
            "name": "display_name",
            "documentation": "Name of this property in form `name: ContainerTypeName<>`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        }
    }
}

{
    "name": "BMM_SIMPLE_TYPE",
    "documentation": "Type reference to a single type i.e. not generic or container type.",
    "ancestors": [
        "BMM_MODEL_TYPE"
    ],
    "properties": {
        "base_class": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "base_class",
            "documentation": "Defining class of this type.",
            "is_mandatory": true,
            "type": "BMM_SIMPLE_CLASS"
        }
    },
    "functions": {
        "type_name": {
            "name": "type_name",
            "documentation": "Result is `_base_class.name_`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        },
        "is_abstract": {
            "name": "is_abstract",
            "documentation": "Result is `_base_class.is_abstract_`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "flattened_type_list": {
            "name": "flattened_type_list",
            "documentation": "Result is `_base_class.name_` .",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            }
        },
        "effective_base_class": {
            "name": "effective_base_class",
            "documentation": "Main design class for this type, from which properties etc can be extracted.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_SIMPLE_CLASS"
            }
        }
    }
}

{
    "name": "BMM_CONTAINER_TYPE",
    "documentation": "Meta-type that specifies linear containers with a generic parameter corresponding to the type of contained item, and whose container type is a generic type such as `List<T>`, `Set<T>` etc.",
    "ancestors": [
        "BMM_TYPE"
    ],
    "properties": {
        "container_class": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "container_class",
            "documentation": "The type of the container. This converts to the `_root_type_` in `BMM_GENERIC_TYPE`.",
            "is_mandatory": true,
            "type": "BMM_GENERIC_CLASS"
        },
        "item_type": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "item_type",
            "documentation": "The container item type.",
            "is_mandatory": true,
            "type": "BMM_UNITARY_TYPE"
        },
        "is_ordered": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "is_ordered",
            "documentation": "True indicates that order of the items in the container attribute is considered significant and must be preserved, e.g. across sessions, serialisation, deserialisation etc. Otherwise known as 'list' semantics.",
            "type": "Boolean",
            "default": true
        },
        "is_unique": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "is_unique",
            "documentation": "True indicates that only unique instances of items in the container are allowed. Otherwise known as 'set' semantics.",
            "type": "Boolean",
            "default": false
        }
    },
    "functions": {
        "type_name": {
            "name": "type_name",
            "documentation": "Return full type name, e.g. `List<ELEMENT>`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        },
        "is_abstract": {
            "name": "is_abstract",
            "documentation": "True if the container class is abstract.",
            "post_conditions": {
                "Post_is_abstract": "Result = container_type.is_abstract"
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "flattened_type_list": {
            "name": "flattened_type_list",
            "documentation": "Flattened list of type names of `_item_type_`, i.e. `_item_type.flattened_type_list_()`.",
            "post_conditions": {
                "Post_result": "Result = item_type.flattened_type_list"
            },
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            }
        },
        "unitary_type": {
            "name": "unitary_type",
            "documentation": "Return `_item_type_`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_UNITARY_TYPE"
            }
        },
        "is_primitive": {
            "name": "is_primitive",
            "documentation": "True if `_item_type_` is primitive.",
            "post_conditions": {
                "Post_validity": "Result = base_class.is_primitive",
                "Post_result": "Result = item_type.is_primitive"
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "effective_type": {
            "name": "effective_type",
            "documentation": "Return `_item_type.effective_type_()`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_EFFECTIVE_TYPE"
            }
        }
    }
}

{
    "name": "BMM_INDEXED_CONTAINER_TYPE",
    "documentation": "Meta-type of linear container type that indexes the contained items in the manner of a standard Hash table, map or dictionary.",
    "ancestors": [
        "BMM_CONTAINER_TYPE"
    ],
    "properties": {
        "index_type": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "index_type",
            "documentation": "Type of the element index, typically `String` or `Integer`, but may be a numeric type or indeed any type from which a hash value can be derived.",
            "is_mandatory": true,
            "type": "BMM_SIMPLE_TYPE"
        }
    },
    "functions": {
        "type_name": {
            "name": "type_name",
            "documentation": "Return full type name, e.g. `HashMap<String, ELEMENT>`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        }
    }
}

{
    "name": "BMM_GENERIC_TYPE",
    "documentation": "Meta-type based on a non-container generic class, e.g. `Packet<Header>`.",
    "ancestors": [
        "BMM_MODEL_TYPE"
    ],
    "properties": {
        "generic_parameters": {
            "_type": "P_BMM_CONTAINER_PROPERTY",
            "name": "generic_parameters",
            "documentation": "Generic parameters of the `_root_type_` in this type specifier. The order must match the order of the owning class's formal generic parameter declarations, and the types may be defined types or formal parameter types.",
            "is_mandatory": true,
            "type_def": {
                "container_type": "List",
                "type": "BMM_UNITARY_TYPE"
            },
            "cardinality": {
                "lower": 1,
                "upper_unbounded": true
            }
        },
        "base_class": {
            "_type": "P_BMM_SINGLE_PROPERTY",
            "name": "base_class",
            "documentation": "Defining generic class of this type.",
            "is_mandatory": true,
            "type": "BMM_GENERIC_CLASS"
        }
    },
    "functions": {
        "type_name": {
            "name": "type_name",
            "documentation": "Return the full name of the type including generic parameters, e.g. `DV_INTERVAL<T>`, `TABLE<List<THING>,String>`.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        },
        "type_signature": {
            "name": "type_signature",
            "documentation": "Signature form of the type, which for generics includes generic parameter constrainer types E.g. `Interval<T:Ordered>`.\n",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        },
        "is_abstract": {
            "name": "is_abstract",
            "documentation": "True if `_base_class.is_abstract_` or if any (non-open) parameter type is abstract.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "flattened_type_list": {
            "name": "flattened_type_list",
            "documentation": "Result is `_base_class.name_` followed by names of all generic parameter type names, which may be open or closed.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            }
        },
        "is_partially_closed": {
            "name": "is_partially_closed",
            "documentation": "Returns True if there is any substituted generic parameter.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        },
        "effective_base_class": {
            "name": "effective_base_class",
            "documentation": "Effective underlying class for this type, abstracting away any container type.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_GENERIC_CLASS"
            }
        },
        "is_open": {
            "name": "is_open",
            "documentation": "True if all generic parameters from ancestor generic types have been substituted in this type.",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "Boolean"
            }
        }
    }
}

{
    "name": "BMM_GENERIC_CLASS",
    "documentation": "Definition of a generic class in an object model.",
    "ancestors": [
        "BMM_CLASS"
    ],
    "properties": {
        "generic_parameters": {
            "_type": "P_BMM_GENERIC_PROPERTY",
            "name": "generic_parameters",
            "documentation": "List of formal generic parameters, keyed by name. These are defined either directly on this class or by the inclusion of an ancestor class which is generic.",
            "is_mandatory": true,
            "type_def": {
                "root_type": "Hash",
                "generic_parameters": [
                    "String",
                    "BMM_PARAMETER_TYPE"
                ]
            }
        }
    },
    "functions": {
        "suppliers": {
            "name": "suppliers",
            "documentation": "Add suppliers from generic parameters.",
            "result": {
                "_type": "P_BMM_CONTAINER_TYPE",
                "container_type": "List",
                "type": "String"
            },
            "is_nullable": true
        },
        "type": {
            "name": "type",
            "documentation": "Generate a fully open `BMM_GENERIC_TYPE` instance that corresponds to this class definition",
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "BMM_GENERIC_TYPE"
            }
        },
        "generic_parameter_conformance_type": {
            "name": "generic_parameter_conformance_type",
            "documentation": "For a generic class, type to which generic parameter `a_name` conforms e.g. if this class is `Interval <T:Comparable>` then the Result will be the single type `Comparable`. For an unconstrained type `T`, the Result will be `Any`.",
            "parameters": {
                "a_name": {
                    "_type": "P_BMM_SINGLE_FUNCTION_PARAMETER",
                    "name": "a_name",
                    "type": "String"
                }
            },
            "result": {
                "_type": "P_BMM_SIMPLE_TYPE",
                "type": "String"
            }
        }
    }
}

{
    "name": "BMM_ENUMERATION",
    "documentation": "Definition of an enumeration class, understood as a class whose value range is constrained extensionally, i.e. by an explicit enumeration of named singleton instances.\n\nOnly one inheritance ancestor is allowed in order to provide the base type to which the range constraint is applied.\n\nThe common notion of a set of literals with no explicit defined values is represented as the degenerate subtype `BMM_ENUMERATION_INTEGER`, whose values are 0, 1, ...",
    "ancestors": [
        "BMM_SIMPLE_CLASS"
    ],
    "properties": {
        "item_names": {
            "_type": "P_BMM_CONTAINER_PROPERTY",
            "name": "item_names",
            "documentation": "The list of names of the enumeration. If no values are supplied, the integer values 0, 1, 2, ... are assumed.",
            "type_def": {
                "container_type": "List",
                "type": "String"
            },
            "cardinality": {
                "lower": 0,
                "upper_unbounded": true
            }
        },
        "item_values": {
            "_type": "P_BMM_CONTAINER_PROPERTY",
            "name": "item_values",
            "documentation": "Optional list of specific values. Must be 1:1 with `_item_names_` list.",
            "type_def": {
                "container_type": "List",
                "type": "BMM_PRIMITIVE_VALUE"
            },
            "cardinality": {
                "lower": 0,
                "upper_unbounded": true
            }
        }
    },
    "functions": {
        "name_map": {
            "name": "name_map",
            "documentation": "Map of `_item_names_` to `_item_values_` (stringified).",
            "result": {
                "_type": "P_BMM_GENERIC_TYPE",
                "root_type": "Hash",
                "generic_parameters": [
                    "String",
                    "String"
                ]
            }
        }
    }
}