diff --git a/.circleci/config.yml b/.circleci/config.yml index 46f515ad18..98b50a9260 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -506,6 +506,29 @@ jobs: - install-solvers - download-corpora + # The metamodel table is generated from the pilot's SysML.ecore at the pin; + # a pin bump without regenerating it fails here. + - restore_cache: + keys: + - pilot-metamodel-v1-{{ checksum "scripts/download-pilot-metamodel.sh" }}-{{ checksum "scripts/pilot-pin.sh" }} + + - run: + name: Download the pilot metamodel + command: ./scripts/download-pilot-metamodel.sh + + - save_cache: + key: pilot-metamodel-v1-{{ checksum "scripts/download-pilot-metamodel.sh" }}-{{ checksum "scripts/pilot-pin.sh" }} + paths: + - build/pilot-metamodel + + - run: + name: Check the metamodel table matches the pinned SysML.ecore + command: make ontology-table-check + + - run: + name: Check generated Python metaclasses are current + command: make python-metamodel-check + # The corpora gate alone, so its per-root verdict lines are legible in the # log and a skip cannot hide behind a green suite. - run: @@ -993,7 +1016,7 @@ jobs: command: | make python-install # Pinned and wheel-only, as in .github/workflows/pr.yml. - pip install --only-binary :all: pytest==9.0.3 pytest-mock==3.15.1 psutil==7.2.2 pytest-cov==7.0.0 fmpy==0.3.32 + pip install --only-binary :all: pytest==9.0.3 pytest-mock==3.15.1 psutil==7.2.2 pytest-cov==7.0.0 fmpy==0.3.32 mypy==2.4.0 types-protobuf==7.35.1.20260906 'pyright[nodejs]==1.1.414' # The integration tests connect to a service on the standard port with # auto_start=False, which is the explicit opt-in to one the client does not @@ -1027,7 +1050,7 @@ jobs: # service is provided here, so its absence is the bug, not a pass. - run: name: Run Python client tests - command: OPENSYSML_REQUIRE_SERVICE=1 OPENSYSML_REQUIRE_REFERENCE_FMUS=1 make python-coverage + command: OPENSYSML_REQUIRE_SERVICE=1 OPENSYSML_REQUIRE_REFERENCE_FMUS=1 OPENSYSML_REQUIRE_TYPECHECKERS=1 make python-coverage # The repository scripts the Go static checks run are Python too; running # them and their tests under coverage here credits what those checks execute. diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml index 2212b119c5..20b5372009 100644 --- a/.github/workflows/pr.yml +++ b/.github/workflows/pr.yml @@ -1240,7 +1240,7 @@ jobs: make python-install # Pinned and wheel-only: an unpinned resolve runs whatever was # published today, and a source distribution runs its own build code. - pip install --only-binary :all: pytest==9.0.3 pytest-mock==3.15.1 psutil==7.2.2 fmpy==0.3.32 + pip install --only-binary :all: pytest==9.0.3 pytest-mock==3.15.1 psutil==7.2.2 fmpy==0.3.32 mypy==2.4.0 types-protobuf==7.35.1.20260906 'pyright[nodejs]==1.1.414' # The FMI runner test's FMUs, same pin as the Go gate's. - name: Cache the Reference-FMUs @@ -1279,6 +1279,7 @@ jobs: - name: Run Python client tests env: OPENSYSML_REQUIRE_SERVICE: 1 + OPENSYSML_REQUIRE_TYPECHECKERS: 1 run: make python-test - name: Verify Python client import diff --git a/Makefile b/Makefile index e564d2bc49..0d36f5733d 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -.PHONY: all build build-sysml build-prod build-wasm-prod build-lsp build-grpc build-engine build-core build-syntax build-sysml-wasm build-release-wasm build-wasm build-wasm-wasip1 build-wasm-js wasm-check static-check windows-versioninfo-check man man-check install-tree pgo-profile conformance conformance-pkg conformance-rust conformance-julia conformance-matlab test test-shard coverage lint clean install help fuml-expected python-test python-coverage scripts-coverage node-coverage python-install proto proto-buf python-proto proto-ts proto-rust proto-lint proto-breaking vscode-grammar vscode-build vscode-package docs docs-install docs-serve docs-engine-assets docs-counts docs-check changelog-check changelog-render self-model +.PHONY: all build build-sysml build-prod build-wasm-prod build-lsp build-grpc build-engine build-core build-syntax build-sysml-wasm build-release-wasm build-wasm build-wasm-wasip1 build-wasm-js wasm-check static-check windows-versioninfo-check man man-check install-tree pgo-profile conformance conformance-pkg conformance-rust conformance-julia conformance-matlab test test-shard coverage lint clean install help ontology-table ontology-table-check python-metamodel python-metamodel-check fuml-expected python-test python-coverage scripts-coverage node-coverage python-install proto proto-buf python-proto proto-ts proto-rust proto-lint proto-breaking vscode-grammar vscode-build vscode-package docs docs-install docs-serve docs-engine-assets docs-counts docs-check changelog-check changelog-render self-model # Version information # Only release tags describe a build; the moving `nightly` tag is not a version. @@ -322,6 +322,24 @@ stdlib-snapshot-check: ## Verify the committed library snapshot matches the bund go run -C $(TOOLS_DIR) ./gen/snapshot -check @echo "✓ stdlib.snapshot is current" +ontology-table: ## Regenerate the metamodel table from the pilot SysML.ecore that scripts/pilot-pin.sh pins + ./scripts/download-pilot-metamodel.sh + go run -C $(TOOLS_DIR) ./gen/ontology + @echo "✓ internal/translate/rdf/ontology/table.go regenerated" + +ontology-table-check: ## Verify the committed metamodel table matches the pinned pilot SysML.ecore, as CI does + ./scripts/download-pilot-metamodel.sh + go run -C $(TOOLS_DIR) ./gen/ontology -check + @echo "✓ internal/translate/rdf/ontology/table.go is current" + +python-metamodel: ## Regenerate Python metaclass classes from the ontology table + go run -C $(TOOLS_DIR) ./gen/pymetamodel + @echo "✓ Python metamodel generated" + +python-metamodel-check: ## Verify generated Python metaclass classes are current + go run -C $(TOOLS_DIR) ./gen/pymetamodel -check + @echo "✓ Python metamodel is current" + fuml-expected: ## Regenerate docs/project/fuml-referee-expected.json from the pinned fUML reference implementation (needs a JDK) ./scripts/fuml-expected.sh @echo "✓ fuml-referee-expected.json regenerated" diff --git a/changes/unreleased/metamodel-reader-validation.fixed.md b/changes/unreleased/metamodel-reader-validation.fixed.md new file mode 100644 index 0000000000..1cccce87c3 --- /dev/null +++ b/changes/unreleased/metamodel-reader-validation.fixed.md @@ -0,0 +1 @@ +- **The metamodel JSON reader unwraps standalone DataVersion envelopes, excludes namespaces with owner metadata from roots, rejects references to the wrong metaclass by default, and rejects non-finite real values.** This reports malformed exported values when read, lets callers opt out of range checking with `check_ranges=False`, and resolves custom metaclasses through `supertypes=`. diff --git a/changes/unreleased/ontology-bounded-many.fixed.md b/changes/unreleased/ontology-bounded-many.fixed.md new file mode 100644 index 0000000000..ee585aec5c --- /dev/null +++ b/changes/unreleased/ontology-bounded-many.fixed.md @@ -0,0 +1 @@ +- **Ecore upper bounds above one are multi-valued in the ontology table.** `MultiplicityRange::bound` and `Flow::flowEnd` (upper bound 2) were marked single-valued; they are now `Many`, so api-json writes them as arrays. diff --git a/changes/unreleased/ontology-pilot-metamodel.changed.md b/changes/unreleased/ontology-pilot-metamodel.changed.md new file mode 100644 index 0000000000..558c97cb27 --- /dev/null +++ b/changes/unreleased/ontology-pilot-metamodel.changed.md @@ -0,0 +1 @@ +- **The metamodel table is generated from the OMG SysML v2 metamodel version 20250201, read from the pinned pilot implementation's `SysML.ecore`, and records each property's ordering, derivation, redefinitions, subsettings and opposite.** It was pinned to the 202407 rendering of `Open-MBEE/sysmlv2-rdf-ontology`, which has not moved since. The table now declares `FlowUsage`, `PayloadFeature`, `FlowEnd`, `TerminateActionUsage` and the other metaclasses added since, so a type owns them through a `sysml:FeatureMembership` and lists them in `sysml:ownedFeature`, as it owns any feature; `nonunique` is written `sysml:isUnique false`, since the metamodel no longer declares `isNonunique`. Graphs written by earlier releases still read. `ontology.Property` gains `Ordered`, `Derived`, `Redefines`, `Subsets` and `Opposite`, `ontology.Class` gains `Abstract`, and the ontology gate reports a subject typed by an abstract metaclass. CI fails when the table drifts from the pinned metamodel (`make ontology-table-check`). diff --git a/changes/unreleased/python-metamodel-reader.added.md b/changes/unreleased/python-metamodel-reader.added.md new file mode 100644 index 0000000000..ba9ca6f6c3 --- /dev/null +++ b/changes/unreleased/python-metamodel-reader.added.md @@ -0,0 +1 @@ +- **Add generated SysML metaclasses and a standalone JSON element reader to the Python client.** Read API and toolkit exports as a lazy typed graph without loading JSON into the engine. diff --git a/client/python/opensysml/__init__.py b/client/python/opensysml/__init__.py index ac9a613d2f..24b1ef1883 100644 --- a/client/python/opensysml/__init__.py +++ b/client/python/opensysml/__init__.py @@ -67,6 +67,7 @@ TypeMismatchError, UnpinnedReleaseError, UnsignedReleaseError, UnsupportedOperationError, UnsupportedValueError, WrongKindError, ) +from opensysml.metamodel import read_json __all__ = [ "Connection", "Model", "Symbol", "Diagnostic", "EnumLiteral", "Instance", @@ -106,7 +107,7 @@ "TypeMismatchError", "UnpinnedReleaseError", "UnsignedReleaseError", "UnsupportedOperationError", "UnsupportedValueError", "WrongKindError", - "load", "loads", "parse_sources", "connect", "convert", "migrate", + "load", "loads", "parse_sources", "connect", "convert", "migrate", "read_json", # "eval" is deprecated in favour of "evaluate", so it is not exported. "evaluate", "instantiate", "DEFAULT_PORT", "split_target", diff --git a/client/python/opensysml/metamodel/__init__.py b/client/python/opensysml/metamodel/__init__.py new file mode 100644 index 0000000000..cc1aa22f1b --- /dev/null +++ b/client/python/opensysml/metamodel/__init__.py @@ -0,0 +1,31 @@ +"""Generated metamodel classes and a reader for exported JSON documents.""" + +# pyright: reportUnsupportedDunderAll=false + +from ._generated import * +from ._generated import __all__ as _generated_all +from ._reader import ElementGraph, read_json +from ._runtime import ( + Many, + MalformedDocument, + MalformedValue, + MetamodelError, + NotSupplied, + Opt, + UnknownJSONKey, + UnresolvedReference, +) + +__all__ = [ + *_generated_all, + "ElementGraph", + "Many", + "MalformedDocument", + "MalformedValue", + "MetamodelError", + "NotSupplied", + "Opt", + "UnknownJSONKey", + "UnresolvedReference", + "read_json", +] diff --git a/client/python/opensysml/metamodel/_generated.py b/client/python/opensysml/metamodel/_generated.py new file mode 100644 index 0000000000..4a18e9de03 --- /dev/null +++ b/client/python/opensysml/metamodel/_generated.py @@ -0,0 +1,3647 @@ +# Code generated by tools/gen/pymetamodel. DO NOT EDIT. +# Metamodel: 20250201 +# Pilot tag: 2026-08 +# Pilot commit: 692170b71867353b8f90341e61556f49a5beb0e5 +# Regenerate with: make python-metamodel + +from __future__ import annotations + +import builtins +from enum import Enum +from types import MappingProxyType +from typing import ClassVar, Mapping + +from ._runtime import Many, Opt, _ElementBase # pyright: ignore[reportPrivateUsage] + +METAMODEL_VERSION = "20250201" +SOURCE_TAG = "2026-08" +SOURCE_COMMIT = "692170b71867353b8f90341e61556f49a5beb0e5" + +class FeatureDirectionKind(str, Enum): + IN = "in" + INOUT = "inout" + OUT = "out" + + +class PortionKind(str, Enum): + TIMESLICE = "timeslice" + SNAPSHOT = "snapshot" + + +class RequirementConstraintKind(str, Enum): + ASSUMPTION = "assumption" + REQUIREMENT = "requirement" + + +class StateSubactionKind(str, Enum): + ENTRY = "entry" + DO = "do" + EXIT = "exit" + + +class TransitionFeatureKind(str, Enum): + TRIGGER = "trigger" + GUARD = "guard" + EFFECT = "effect" + + +class TriggerKind(str, Enum): + WHEN = "when" + AT = "at" + AFTER = "after" + + +class VisibilityKind(str, Enum): + PRIVATE = "private" + PROTECTED = "protected" + PUBLIC = "public" + + +class Element(_ElementBase): + "Abstract metaclass ``Element``." + __slots__ = () + METACLASS: ClassVar[str] = "Element" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **_ElementBase.JSON_KEYS, + "aliasIds": "alias_ids", + "declaredName": "declared_name", + "declaredShortName": "declared_short_name", + "documentation": "documentation", + "elementId": "element_id", + "isImpliedIncluded": "is_implied_included", + "isLibraryElement": "is_library_element", + "name": "name", + "ownedAnnotation": "owned_annotation", + "ownedElement": "owned_element", + "ownedRelationship": "owned_relationship", + "owner": "owner", + "owningMembership": "owning_membership", + "owningNamespace": "owning_namespace", + "owningRelationship": "owning_relationship", + "qualifiedName": "qualified_name", + "shortName": "short_name", + "textualRepresentation": "textual_representation", + }) + alias_ids: Many[str] = Many("aliasIds", "str", ordered=True) + "``Element::aliasIds`` (many, ordered)." + aliasIds = alias_ids + declared_name: Opt[str] = Opt("declaredName", "str") + "``Element::declaredName`` (single)." + declaredName = declared_name + declared_short_name: Opt[str] = Opt("declaredShortName", "str") + "``Element::declaredShortName`` (single)." + declaredShortName = declared_short_name + documentation: Many[Documentation] = Many("documentation", "Documentation", ordered=True, derived=True) + "``Element::documentation`` (many, ordered, derived)." + element_id: Opt[str] = Opt("elementId", "str") + "``Element::elementId`` (single)." + elementId = element_id + is_implied_included: Opt[bool] = Opt("isImpliedIncluded", "bool") + "``Element::isImpliedIncluded`` (single)." + isImpliedIncluded = is_implied_included + is_library_element: Opt[bool] = Opt("isLibraryElement", "bool", derived=True) + "``Element::isLibraryElement`` (single, derived)." + isLibraryElement = is_library_element + name: Opt[str] = Opt("name", "str", derived=True) + "``Element::name`` (single, derived)." + owned_annotation: Many[Annotation] = Many("ownedAnnotation", "Annotation", ordered=True, derived=True) + "``Element::ownedAnnotation`` (many, ordered, derived)." + ownedAnnotation = owned_annotation + owned_element: Many[Element] = Many("ownedElement", "Element", ordered=True, derived=True) + "``Element::ownedElement`` (many, ordered, derived)." + ownedElement = owned_element + owned_relationship: Many[Relationship] = Many("ownedRelationship", "Relationship", ordered=True) + "``Element::ownedRelationship`` (many, ordered)." + ownedRelationship = owned_relationship + owner: Opt[Element] = Opt("owner", "Element", derived=True) + "``Element::owner`` (single, derived)." + owning_membership: Opt[OwningMembership] = Opt("owningMembership", "OwningMembership", derived=True) + "``Element::owningMembership`` (single, derived)." + owningMembership = owning_membership + owning_namespace: Opt[Namespace] = Opt("owningNamespace", "Namespace", derived=True) + "``Element::owningNamespace`` (single, derived)." + owningNamespace = owning_namespace + owning_relationship: Opt[Relationship] = Opt("owningRelationship", "Relationship") + "``Element::owningRelationship`` (single)." + owningRelationship = owning_relationship + qualified_name: Opt[str] = Opt("qualifiedName", "str", derived=True) + "``Element::qualifiedName`` (single, derived)." + qualifiedName = qualified_name + short_name: Opt[str] = Opt("shortName", "str", derived=True) + "``Element::shortName`` (single, derived)." + shortName = short_name + textual_representation: Many[TextualRepresentation] = Many("textualRepresentation", "TextualRepresentation", ordered=True, derived=True) + "``Element::textualRepresentation`` (many, ordered, derived)." + textualRepresentation = textual_representation + + +class AnnotatingElement(Element): + "Metaclass ``AnnotatingElement``." + __slots__ = () + METACLASS: ClassVar[str] = "AnnotatingElement" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Element.JSON_KEYS, + "annotatedElement": "annotated_element", + "annotation": "annotation", + "ownedAnnotatingRelationship": "owned_annotating_relationship", + "owningAnnotatingRelationship": "owning_annotating_relationship", + }) + annotated_element: Many[Element] = Many("annotatedElement", "Element", ordered=True, derived=True) + "``AnnotatingElement::annotatedElement`` (many, ordered, derived)." + annotatedElement = annotated_element + annotation: Many[Annotation] = Many("annotation", "Annotation", ordered=True, derived=True) + "``AnnotatingElement::annotation`` (many, ordered, derived)." + owned_annotating_relationship: Many[Annotation] = Many("ownedAnnotatingRelationship", "Annotation", ordered=True, derived=True) + "``AnnotatingElement::ownedAnnotatingRelationship`` (many, ordered, derived)." + ownedAnnotatingRelationship = owned_annotating_relationship + owning_annotating_relationship: Opt[Annotation] = Opt("owningAnnotatingRelationship", "Annotation", derived=True) + "``AnnotatingElement::owningAnnotatingRelationship`` (single, derived)." + owningAnnotatingRelationship = owning_annotating_relationship + + +class Comment(AnnotatingElement): + "Metaclass ``Comment``." + __slots__ = () + METACLASS: ClassVar[str] = "Comment" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **AnnotatingElement.JSON_KEYS, + "body": "body", + "locale": "locale", + }) + body: Opt[str] = Opt("body", "str") + "``Comment::body`` (single)." + locale: Opt[str] = Opt("locale", "str") + "``Comment::locale`` (single)." + + +class Documentation(Comment): + "Metaclass ``Documentation``." + __slots__ = () + METACLASS: ClassVar[str] = "Documentation" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Comment.JSON_KEYS, + "documentedElement": "documented_element", + }) + documented_element: Opt[Element] = Opt("documentedElement", "Element", derived=True) + "``Documentation::documentedElement`` (single, derived). Redefines ``AnnotatingElement::annotatedElement``." + documentedElement = documented_element + + +class Namespace(Element): + "Metaclass ``Namespace``." + __slots__ = () + METACLASS: ClassVar[str] = "Namespace" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Element.JSON_KEYS, + "importedMembership": "imported_membership", + "member": "member", + "membership": "membership", + "ownedImport": "owned_import", + "ownedMember": "owned_member", + "ownedMembership": "owned_membership", + }) + imported_membership: Many[Membership] = Many("importedMembership", "Membership", ordered=True, derived=True) + "``Namespace::importedMembership`` (many, ordered, derived)." + importedMembership = imported_membership + member: Many[Element] = Many("member", "Element", ordered=True, derived=True) + "``Namespace::member`` (many, ordered, derived)." + membership: Many[Membership] = Many("membership", "Membership", ordered=True, derived=True) + "``Namespace::membership`` (many, ordered, derived)." + owned_import: Many[Import] = Many("ownedImport", "Import", ordered=True, derived=True) + "``Namespace::ownedImport`` (many, ordered, derived)." + ownedImport = owned_import + owned_member: Many[Element] = Many("ownedMember", "Element", ordered=True, derived=True) + "``Namespace::ownedMember`` (many, ordered, derived)." + ownedMember = owned_member + owned_membership: Many[Membership] = Many("ownedMembership", "Membership", ordered=True, derived=True) + "``Namespace::ownedMembership`` (many, ordered, derived)." + ownedMembership = owned_membership + + +class Package(Namespace): + "Metaclass ``Package``." + __slots__ = () + METACLASS: ClassVar[str] = "Package" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Namespace.JSON_KEYS, + "filterCondition": "filter_condition", + }) + filter_condition: Many[Expression] = Many("filterCondition", "Expression", ordered=True, derived=True) + "``Package::filterCondition`` (many, ordered, derived)." + filterCondition = filter_condition + + +class LibraryPackage(Package): + "Metaclass ``LibraryPackage``." + __slots__ = () + METACLASS: ClassVar[str] = "LibraryPackage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Package.JSON_KEYS, + "isStandard": "is_standard", + }) + is_standard: Opt[bool] = Opt("isStandard", "bool") + "``LibraryPackage::isStandard`` (single)." + isStandard = is_standard + + +class Relationship(Element): + "Abstract metaclass ``Relationship``." + __slots__ = () + METACLASS: ClassVar[str] = "Relationship" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Element.JSON_KEYS, + "isImplied": "is_implied", + "ownedRelatedElement": "owned_related_element", + "owningRelatedElement": "owning_related_element", + "relatedElement": "related_element", + "source": "source", + "target": "target", + }) + is_implied: Opt[bool] = Opt("isImplied", "bool") + "``Relationship::isImplied`` (single)." + isImplied = is_implied + owned_related_element: Many[Element] = Many("ownedRelatedElement", "Element", ordered=True) + "``Relationship::ownedRelatedElement`` (many, ordered)." + ownedRelatedElement = owned_related_element + owning_related_element: Opt[Element] = Opt("owningRelatedElement", "Element") + "``Relationship::owningRelatedElement`` (single)." + owningRelatedElement = owning_related_element + related_element: Many[Element] = Many("relatedElement", "Element", ordered=True, derived=True) + "``Relationship::relatedElement`` (many, ordered, derived)." + relatedElement = related_element + source: Many[Element] = Many("source", "Element", ordered=True) + "``Relationship::source`` (many, ordered)." + target: Many[Element] = Many("target", "Element", ordered=True) + "``Relationship::target`` (many, ordered)." + + +class Annotation(Relationship): + "Metaclass ``Annotation``." + __slots__ = () + METACLASS: ClassVar[str] = "Annotation" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "annotatedElement": "annotated_element", + "annotatingElement": "annotating_element", + "ownedAnnotatingElement": "owned_annotating_element", + "owningAnnotatedElement": "owning_annotated_element", + "owningAnnotatingElement": "owning_annotating_element", + }) + annotated_element: Opt[Element] = Opt("annotatedElement", "Element") + "``Annotation::annotatedElement`` (single). Redefines ``Relationship::target``." + annotatedElement = annotated_element + annotating_element: Opt[AnnotatingElement] = Opt("annotatingElement", "AnnotatingElement", derived=True) + "``Annotation::annotatingElement`` (single, derived). Redefines ``Relationship::source``." + annotatingElement = annotating_element + owned_annotating_element: Opt[AnnotatingElement] = Opt("ownedAnnotatingElement", "AnnotatingElement", derived=True) + "``Annotation::ownedAnnotatingElement`` (single, derived)." + ownedAnnotatingElement = owned_annotating_element + owning_annotated_element: Opt[Element] = Opt("owningAnnotatedElement", "Element", derived=True) + "``Annotation::owningAnnotatedElement`` (single, derived)." + owningAnnotatedElement = owning_annotated_element + owning_annotating_element: Opt[AnnotatingElement] = Opt("owningAnnotatingElement", "AnnotatingElement", derived=True) + "``Annotation::owningAnnotatingElement`` (single, derived)." + owningAnnotatingElement = owning_annotating_element + + +class Conjugation(Relationship): + "Metaclass ``Conjugation``." + __slots__ = () + METACLASS: ClassVar[str] = "Conjugation" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "conjugatedType": "conjugated_type", + "originalType": "original_type", + "owningType": "owning_type", + }) + conjugated_type: Opt[Type] = Opt("conjugatedType", "Type") + "``Conjugation::conjugatedType`` (single). Redefines ``Relationship::source``." + conjugatedType = conjugated_type + original_type: Opt[Type] = Opt("originalType", "Type") + "``Conjugation::originalType`` (single). Redefines ``Relationship::target``." + originalType = original_type + owning_type: Opt[Type] = Opt("owningType", "Type", derived=True) + "``Conjugation::owningType`` (single, derived)." + owningType = owning_type + + +class Dependency(Relationship): + "Metaclass ``Dependency``." + __slots__ = () + METACLASS: ClassVar[str] = "Dependency" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "client": "client", + "supplier": "supplier", + }) + client: Many[Element] = Many("client", "Element", ordered=True) + "``Dependency::client`` (many, ordered). Redefines ``Relationship::source``." + supplier: Many[Element] = Many("supplier", "Element", ordered=True) + "``Dependency::supplier`` (many, ordered). Redefines ``Relationship::target``." + + +class Differencing(Relationship): + "Metaclass ``Differencing``." + __slots__ = () + METACLASS: ClassVar[str] = "Differencing" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "differencingType": "differencing_type", + "typeDifferenced": "type_differenced", + }) + differencing_type: Opt[Type] = Opt("differencingType", "Type") + "``Differencing::differencingType`` (single). Redefines ``Relationship::target``." + differencingType = differencing_type + type_differenced: Opt[Type] = Opt("typeDifferenced", "Type", derived=True) + "``Differencing::typeDifferenced`` (single, derived). Redefines ``Relationship::source``." + typeDifferenced = type_differenced + + +class Disjoining(Relationship): + "Metaclass ``Disjoining``." + __slots__ = () + METACLASS: ClassVar[str] = "Disjoining" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "disjoiningType": "disjoining_type", + "owningType": "owning_type", + "typeDisjoined": "type_disjoined", + }) + disjoining_type: Opt[Type] = Opt("disjoiningType", "Type") + "``Disjoining::disjoiningType`` (single). Redefines ``Relationship::target``." + disjoiningType = disjoining_type + owning_type: Opt[Type] = Opt("owningType", "Type", derived=True) + "``Disjoining::owningType`` (single, derived)." + owningType = owning_type + type_disjoined: Opt[Type] = Opt("typeDisjoined", "Type") + "``Disjoining::typeDisjoined`` (single). Redefines ``Relationship::source``." + typeDisjoined = type_disjoined + + +class FeatureChaining(Relationship): + "Metaclass ``FeatureChaining``." + __slots__ = () + METACLASS: ClassVar[str] = "FeatureChaining" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "chainingFeature": "chaining_feature", + "featureChained": "feature_chained", + }) + chaining_feature: Opt[Feature] = Opt("chainingFeature", "Feature") + "``FeatureChaining::chainingFeature`` (single). Redefines ``Relationship::target``." + chainingFeature = chaining_feature + feature_chained: Opt[Feature] = Opt("featureChained", "Feature", derived=True) + "``FeatureChaining::featureChained`` (single, derived). Redefines ``Relationship::source``." + featureChained = feature_chained + + +class FeatureInverting(Relationship): + "Metaclass ``FeatureInverting``." + __slots__ = () + METACLASS: ClassVar[str] = "FeatureInverting" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "featureInverted": "feature_inverted", + "invertingFeature": "inverting_feature", + "owningFeature": "owning_feature", + }) + feature_inverted: Opt[Feature] = Opt("featureInverted", "Feature") + "``FeatureInverting::featureInverted`` (single). Redefines ``Relationship::source``." + featureInverted = feature_inverted + inverting_feature: Opt[Feature] = Opt("invertingFeature", "Feature") + "``FeatureInverting::invertingFeature`` (single). Redefines ``Relationship::target``." + invertingFeature = inverting_feature + owning_feature: Opt[Feature] = Opt("owningFeature", "Feature", derived=True) + "``FeatureInverting::owningFeature`` (single, derived)." + owningFeature = owning_feature + + +class Import(Relationship): + "Abstract metaclass ``Import``." + __slots__ = () + METACLASS: ClassVar[str] = "Import" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "importOwningNamespace": "import_owning_namespace", + "importedElement": "imported_element", + "isImportAll": "is_import_all", + "isRecursive": "is_recursive", + "visibility": "visibility", + }) + import_owning_namespace: Opt[Namespace] = Opt("importOwningNamespace", "Namespace", derived=True) + "``Import::importOwningNamespace`` (single, derived). Redefines ``Relationship::source``." + importOwningNamespace = import_owning_namespace + imported_element: Opt[Element] = Opt("importedElement", "Element", derived=True) + "``Import::importedElement`` (single, derived)." + importedElement = imported_element + is_import_all: Opt[bool] = Opt("isImportAll", "bool") + "``Import::isImportAll`` (single)." + isImportAll = is_import_all + is_recursive: Opt[bool] = Opt("isRecursive", "bool") + "``Import::isRecursive`` (single)." + isRecursive = is_recursive + visibility: Opt[VisibilityKind] = Opt("visibility", "VisibilityKind") + "``Import::visibility`` (single)." + + +class Expose(Import): + "Abstract metaclass ``Expose``." + __slots__ = () + METACLASS: ClassVar[str] = "Expose" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Import.JSON_KEYS, + }) + + +class Intersecting(Relationship): + "Metaclass ``Intersecting``." + __slots__ = () + METACLASS: ClassVar[str] = "Intersecting" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "intersectingType": "intersecting_type", + "typeIntersected": "type_intersected", + }) + intersecting_type: Opt[Type] = Opt("intersectingType", "Type") + "``Intersecting::intersectingType`` (single). Redefines ``Relationship::target``." + intersectingType = intersecting_type + type_intersected: Opt[Type] = Opt("typeIntersected", "Type", derived=True) + "``Intersecting::typeIntersected`` (single, derived). Redefines ``Relationship::source``." + typeIntersected = type_intersected + + +class Membership(Relationship): + "Metaclass ``Membership``." + __slots__ = () + METACLASS: ClassVar[str] = "Membership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "memberElement": "member_element", + "memberElementId": "member_element_id", + "memberName": "member_name", + "memberShortName": "member_short_name", + "membershipOwningNamespace": "membership_owning_namespace", + "visibility": "visibility", + }) + member_element: Opt[Element] = Opt("memberElement", "Element") + "``Membership::memberElement`` (single). Redefines ``Relationship::target``." + memberElement = member_element + member_element_id: Opt[str] = Opt("memberElementId", "str", derived=True) + "``Membership::memberElementId`` (single, derived)." + memberElementId = member_element_id + member_name: Opt[str] = Opt("memberName", "str") + "``Membership::memberName`` (single)." + memberName = member_name + member_short_name: Opt[str] = Opt("memberShortName", "str") + "``Membership::memberShortName`` (single)." + memberShortName = member_short_name + membership_owning_namespace: Opt[Namespace] = Opt("membershipOwningNamespace", "Namespace", derived=True) + "``Membership::membershipOwningNamespace`` (single, derived). Redefines ``Relationship::source``." + membershipOwningNamespace = membership_owning_namespace + visibility: Opt[VisibilityKind] = Opt("visibility", "VisibilityKind") + "``Membership::visibility`` (single)." + + +class MembershipImport(Import): + "Metaclass ``MembershipImport``." + __slots__ = () + METACLASS: ClassVar[str] = "MembershipImport" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Import.JSON_KEYS, + "importedMembership": "imported_membership", + }) + imported_membership: Opt[Membership] = Opt("importedMembership", "Membership") + "``MembershipImport::importedMembership`` (single). Redefines ``Relationship::target``." + importedMembership = imported_membership + + +class MembershipExpose(Expose, MembershipImport): + "Metaclass ``MembershipExpose``." + __slots__ = () + METACLASS: ClassVar[str] = "MembershipExpose" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **MembershipImport.JSON_KEYS, + **Expose.JSON_KEYS, + }) + + +class NamespaceImport(Import): + "Metaclass ``NamespaceImport``." + __slots__ = () + METACLASS: ClassVar[str] = "NamespaceImport" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Import.JSON_KEYS, + "importedNamespace": "imported_namespace", + }) + imported_namespace: Opt[Namespace] = Opt("importedNamespace", "Namespace") + "``NamespaceImport::importedNamespace`` (single). Redefines ``Relationship::target``." + importedNamespace = imported_namespace + + +class NamespaceExpose(Expose, NamespaceImport): + "Metaclass ``NamespaceExpose``." + __slots__ = () + METACLASS: ClassVar[str] = "NamespaceExpose" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **NamespaceImport.JSON_KEYS, + **Expose.JSON_KEYS, + }) + + +class OwningMembership(Membership): + "Metaclass ``OwningMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "OwningMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Membership.JSON_KEYS, + "ownedMemberElement": "owned_member_element", + "ownedMemberElementId": "owned_member_element_id", + "ownedMemberName": "owned_member_name", + "ownedMemberShortName": "owned_member_short_name", + }) + owned_member_element: Opt[Element] = Opt("ownedMemberElement", "Element", derived=True) + "``OwningMembership::ownedMemberElement`` (single, derived). Redefines ``Membership::memberElement``." + ownedMemberElement = owned_member_element + owned_member_element_id: Opt[str] = Opt("ownedMemberElementId", "str", derived=True) + "``OwningMembership::ownedMemberElementId`` (single, derived). Redefines ``Membership::memberElementId``." + ownedMemberElementId = owned_member_element_id + owned_member_name: Opt[str] = Opt("ownedMemberName", "str", derived=True) + "``OwningMembership::ownedMemberName`` (single, derived). Redefines ``Membership::memberName``." + ownedMemberName = owned_member_name + owned_member_short_name: Opt[str] = Opt("ownedMemberShortName", "str", derived=True) + "``OwningMembership::ownedMemberShortName`` (single, derived). Redefines ``Membership::memberShortName``." + ownedMemberShortName = owned_member_short_name + + +class ElementFilterMembership(OwningMembership): + "Metaclass ``ElementFilterMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "ElementFilterMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OwningMembership.JSON_KEYS, + "condition": "condition", + }) + condition: Opt[Expression] = Opt("condition", "Expression", derived=True) + "``ElementFilterMembership::condition`` (single, derived). Redefines ``OwningMembership::ownedMemberElement``." + + +class FeatureMembership(OwningMembership): + "Metaclass ``FeatureMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "FeatureMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OwningMembership.JSON_KEYS, + "ownedMemberFeature": "owned_member_feature", + "owningType": "owning_type", + }) + owned_member_feature: Opt[Feature] = Opt("ownedMemberFeature", "Feature", derived=True) + "``FeatureMembership::ownedMemberFeature`` (single, derived). Redefines ``OwningMembership::ownedMemberElement``." + ownedMemberFeature = owned_member_feature + owning_type: Opt[Type] = Opt("owningType", "Type", derived=True) + "``FeatureMembership::owningType`` (single, derived). Redefines ``Membership::membershipOwningNamespace``." + owningType = owning_type + + +class EndFeatureMembership(FeatureMembership): + "Metaclass ``EndFeatureMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "EndFeatureMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **FeatureMembership.JSON_KEYS, + }) + + +class FeatureValue(OwningMembership): + "Metaclass ``FeatureValue``." + __slots__ = () + METACLASS: ClassVar[str] = "FeatureValue" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OwningMembership.JSON_KEYS, + "featureWithValue": "feature_with_value", + "isDefault": "is_default", + "isInitial": "is_initial", + "value": "value", + }) + feature_with_value: Opt[Feature] = Opt("featureWithValue", "Feature", derived=True) + "``FeatureValue::featureWithValue`` (single, derived)." + featureWithValue = feature_with_value + is_default: Opt[bool] = Opt("isDefault", "bool") + "``FeatureValue::isDefault`` (single)." + isDefault = is_default + is_initial: Opt[bool] = Opt("isInitial", "bool") + "``FeatureValue::isInitial`` (single)." + isInitial = is_initial + value: Opt[Expression] = Opt("value", "Expression", derived=True) + "``FeatureValue::value`` (single, derived). Redefines ``OwningMembership::ownedMemberElement``." + + +class ObjectiveMembership(FeatureMembership): + "Metaclass ``ObjectiveMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "ObjectiveMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **FeatureMembership.JSON_KEYS, + "ownedObjectiveRequirement": "owned_objective_requirement", + }) + owned_objective_requirement: Opt[RequirementUsage] = Opt("ownedObjectiveRequirement", "RequirementUsage", derived=True) + "``ObjectiveMembership::ownedObjectiveRequirement`` (single, derived). Redefines ``FeatureMembership::ownedMemberFeature``." + ownedObjectiveRequirement = owned_objective_requirement + + +class ParameterMembership(FeatureMembership): + "Metaclass ``ParameterMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "ParameterMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **FeatureMembership.JSON_KEYS, + "ownedMemberParameter": "owned_member_parameter", + }) + owned_member_parameter: Opt[Feature] = Opt("ownedMemberParameter", "Feature", derived=True) + "``ParameterMembership::ownedMemberParameter`` (single, derived). Redefines ``FeatureMembership::ownedMemberFeature``." + ownedMemberParameter = owned_member_parameter + + +class ActorMembership(ParameterMembership): + "Metaclass ``ActorMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "ActorMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ParameterMembership.JSON_KEYS, + "ownedActorParameter": "owned_actor_parameter", + }) + owned_actor_parameter: Opt[PartUsage] = Opt("ownedActorParameter", "PartUsage", derived=True) + "``ActorMembership::ownedActorParameter`` (single, derived). Redefines ``ParameterMembership::ownedMemberParameter``." + ownedActorParameter = owned_actor_parameter + + +class PortConjugation(Conjugation): + "Metaclass ``PortConjugation``." + __slots__ = () + METACLASS: ClassVar[str] = "PortConjugation" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Conjugation.JSON_KEYS, + "conjugatedPortDefinition": "conjugated_port_definition", + "originalPortDefinition": "original_port_definition", + }) + conjugated_port_definition: Opt[ConjugatedPortDefinition] = Opt("conjugatedPortDefinition", "ConjugatedPortDefinition", derived=True) + "``PortConjugation::conjugatedPortDefinition`` (single, derived). Redefines ``Conjugation::owningType``." + conjugatedPortDefinition = conjugated_port_definition + original_port_definition: Opt[PortDefinition] = Opt("originalPortDefinition", "PortDefinition") + "``PortConjugation::originalPortDefinition`` (single). Redefines ``Conjugation::originalType``." + originalPortDefinition = original_port_definition + + +class RequirementConstraintMembership(FeatureMembership): + "Metaclass ``RequirementConstraintMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "RequirementConstraintMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **FeatureMembership.JSON_KEYS, + "kind": "kind", + "ownedConstraint": "owned_constraint", + "referencedConstraint": "referenced_constraint", + }) + kind: Opt[RequirementConstraintKind] = Opt("kind", "RequirementConstraintKind") + "``RequirementConstraintMembership::kind`` (single)." + owned_constraint: Opt[ConstraintUsage] = Opt("ownedConstraint", "ConstraintUsage", derived=True) + "``RequirementConstraintMembership::ownedConstraint`` (single, derived). Redefines ``FeatureMembership::ownedMemberFeature``." + ownedConstraint = owned_constraint + referenced_constraint: Opt[ConstraintUsage] = Opt("referencedConstraint", "ConstraintUsage", derived=True) + "``RequirementConstraintMembership::referencedConstraint`` (single, derived)." + referencedConstraint = referenced_constraint + + +class FramedConcernMembership(RequirementConstraintMembership): + "Metaclass ``FramedConcernMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "FramedConcernMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **RequirementConstraintMembership.JSON_KEYS, + "ownedConcern": "owned_concern", + "referencedConcern": "referenced_concern", + }) + owned_concern: Opt[ConcernUsage] = Opt("ownedConcern", "ConcernUsage", derived=True) + "``FramedConcernMembership::ownedConcern`` (single, derived). Redefines ``RequirementConstraintMembership::ownedConstraint``." + ownedConcern = owned_concern + referenced_concern: Opt[ConcernUsage] = Opt("referencedConcern", "ConcernUsage", derived=True) + "``FramedConcernMembership::referencedConcern`` (single, derived). Redefines ``RequirementConstraintMembership::referencedConstraint``." + referencedConcern = referenced_concern + + +class RequirementVerificationMembership(RequirementConstraintMembership): + "Metaclass ``RequirementVerificationMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "RequirementVerificationMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **RequirementConstraintMembership.JSON_KEYS, + "ownedRequirement": "owned_requirement", + "verifiedRequirement": "verified_requirement", + }) + owned_requirement: Opt[RequirementUsage] = Opt("ownedRequirement", "RequirementUsage", derived=True) + "``RequirementVerificationMembership::ownedRequirement`` (single, derived). Redefines ``RequirementConstraintMembership::ownedConstraint``." + ownedRequirement = owned_requirement + verified_requirement: Opt[RequirementUsage] = Opt("verifiedRequirement", "RequirementUsage", derived=True) + "``RequirementVerificationMembership::verifiedRequirement`` (single, derived). Redefines ``RequirementConstraintMembership::referencedConstraint``." + verifiedRequirement = verified_requirement + + +class ResultExpressionMembership(FeatureMembership): + "Metaclass ``ResultExpressionMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "ResultExpressionMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **FeatureMembership.JSON_KEYS, + "ownedResultExpression": "owned_result_expression", + }) + owned_result_expression: Opt[Expression] = Opt("ownedResultExpression", "Expression", derived=True) + "``ResultExpressionMembership::ownedResultExpression`` (single, derived). Redefines ``FeatureMembership::ownedMemberFeature``." + ownedResultExpression = owned_result_expression + + +class ReturnParameterMembership(ParameterMembership): + "Metaclass ``ReturnParameterMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "ReturnParameterMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ParameterMembership.JSON_KEYS, + }) + + +class Specialization(Relationship): + "Metaclass ``Specialization``." + __slots__ = () + METACLASS: ClassVar[str] = "Specialization" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "general": "general", + "owningType": "owning_type", + "specific": "specific", + }) + general: Opt[Type] = Opt("general", "Type") + "``Specialization::general`` (single). Redefines ``Relationship::target``." + owning_type: Opt[Type] = Opt("owningType", "Type", derived=True) + "``Specialization::owningType`` (single, derived)." + owningType = owning_type + specific: Opt[Type] = Opt("specific", "Type") + "``Specialization::specific`` (single). Redefines ``Relationship::source``." + + +class FeatureTyping(Specialization): + "Metaclass ``FeatureTyping``." + __slots__ = () + METACLASS: ClassVar[str] = "FeatureTyping" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Specialization.JSON_KEYS, + "owningFeature": "owning_feature", + "type": "type", + "typedFeature": "typed_feature", + }) + owning_feature: Opt[Feature] = Opt("owningFeature", "Feature", derived=True) + "``FeatureTyping::owningFeature`` (single, derived). Redefines ``Specialization::owningType``." + owningFeature = owning_feature + type: Opt[Type] = Opt("type", "Type") + "``FeatureTyping::type`` (single). Redefines ``Specialization::general``." + typed_feature: Opt[Feature] = Opt("typedFeature", "Feature") + "``FeatureTyping::typedFeature`` (single). Redefines ``Specialization::specific``." + typedFeature = typed_feature + + +class ConjugatedPortTyping(FeatureTyping): + "Metaclass ``ConjugatedPortTyping``." + __slots__ = () + METACLASS: ClassVar[str] = "ConjugatedPortTyping" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **FeatureTyping.JSON_KEYS, + "conjugatedPortDefinition": "conjugated_port_definition", + "portDefinition": "port_definition", + }) + conjugated_port_definition: Opt[ConjugatedPortDefinition] = Opt("conjugatedPortDefinition", "ConjugatedPortDefinition") + "``ConjugatedPortTyping::conjugatedPortDefinition`` (single). Redefines ``FeatureTyping::type``." + conjugatedPortDefinition = conjugated_port_definition + port_definition: Opt[PortDefinition] = Opt("portDefinition", "PortDefinition", derived=True) + "``ConjugatedPortTyping::portDefinition`` (single, derived)." + portDefinition = port_definition + + +class StakeholderMembership(ParameterMembership): + "Metaclass ``StakeholderMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "StakeholderMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ParameterMembership.JSON_KEYS, + "ownedStakeholderParameter": "owned_stakeholder_parameter", + }) + owned_stakeholder_parameter: Opt[PartUsage] = Opt("ownedStakeholderParameter", "PartUsage", derived=True) + "``StakeholderMembership::ownedStakeholderParameter`` (single, derived). Redefines ``ParameterMembership::ownedMemberParameter``." + ownedStakeholderParameter = owned_stakeholder_parameter + + +class StateSubactionMembership(FeatureMembership): + "Metaclass ``StateSubactionMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "StateSubactionMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **FeatureMembership.JSON_KEYS, + "action": "action", + "kind": "kind", + }) + action: Opt[ActionUsage] = Opt("action", "ActionUsage", derived=True) + "``StateSubactionMembership::action`` (single, derived). Redefines ``FeatureMembership::ownedMemberFeature``." + kind: Opt[StateSubactionKind] = Opt("kind", "StateSubactionKind") + "``StateSubactionMembership::kind`` (single)." + + +class Subclassification(Specialization): + "Metaclass ``Subclassification``." + __slots__ = () + METACLASS: ClassVar[str] = "Subclassification" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Specialization.JSON_KEYS, + "owningClassifier": "owning_classifier", + "subclassifier": "subclassifier", + "superclassifier": "superclassifier", + }) + owning_classifier: Opt[Classifier] = Opt("owningClassifier", "Classifier", derived=True) + "``Subclassification::owningClassifier`` (single, derived). Redefines ``Specialization::owningType``." + owningClassifier = owning_classifier + subclassifier: Opt[Classifier] = Opt("subclassifier", "Classifier") + "``Subclassification::subclassifier`` (single). Redefines ``Specialization::specific``." + superclassifier: Opt[Classifier] = Opt("superclassifier", "Classifier") + "``Subclassification::superclassifier`` (single). Redefines ``Specialization::general``." + + +class SubjectMembership(ParameterMembership): + "Metaclass ``SubjectMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "SubjectMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ParameterMembership.JSON_KEYS, + "ownedSubjectParameter": "owned_subject_parameter", + }) + owned_subject_parameter: Opt[Usage] = Opt("ownedSubjectParameter", "Usage", derived=True) + "``SubjectMembership::ownedSubjectParameter`` (single, derived). Redefines ``ParameterMembership::ownedMemberParameter``." + ownedSubjectParameter = owned_subject_parameter + + +class Subsetting(Specialization): + "Metaclass ``Subsetting``." + __slots__ = () + METACLASS: ClassVar[str] = "Subsetting" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Specialization.JSON_KEYS, + "owningFeature": "owning_feature", + "subsettedFeature": "subsetted_feature", + "subsettingFeature": "subsetting_feature", + }) + owning_feature: Opt[Feature] = Opt("owningFeature", "Feature", derived=True) + "``Subsetting::owningFeature`` (single, derived). Redefines ``Specialization::owningType``." + owningFeature = owning_feature + subsetted_feature: Opt[Feature] = Opt("subsettedFeature", "Feature") + "``Subsetting::subsettedFeature`` (single). Redefines ``Specialization::general``." + subsettedFeature = subsetted_feature + subsetting_feature: Opt[Feature] = Opt("subsettingFeature", "Feature") + "``Subsetting::subsettingFeature`` (single). Redefines ``Specialization::specific``." + subsettingFeature = subsetting_feature + + +class CrossSubsetting(Subsetting): + "Metaclass ``CrossSubsetting``." + __slots__ = () + METACLASS: ClassVar[str] = "CrossSubsetting" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Subsetting.JSON_KEYS, + "crossedFeature": "crossed_feature", + "crossingFeature": "crossing_feature", + }) + crossed_feature: Opt[Feature] = Opt("crossedFeature", "Feature") + "``CrossSubsetting::crossedFeature`` (single). Redefines ``Subsetting::subsettedFeature``." + crossedFeature = crossed_feature + crossing_feature: Opt[Feature] = Opt("crossingFeature", "Feature", derived=True) + "``CrossSubsetting::crossingFeature`` (single, derived). Redefines ``Subsetting::owningFeature``, ``Subsetting::subsettingFeature``." + crossingFeature = crossing_feature + + +class Redefinition(Subsetting): + "Metaclass ``Redefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "Redefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Subsetting.JSON_KEYS, + "redefinedFeature": "redefined_feature", + "redefiningFeature": "redefining_feature", + }) + redefined_feature: Opt[Feature] = Opt("redefinedFeature", "Feature") + "``Redefinition::redefinedFeature`` (single). Redefines ``Subsetting::subsettedFeature``." + redefinedFeature = redefined_feature + redefining_feature: Opt[Feature] = Opt("redefiningFeature", "Feature") + "``Redefinition::redefiningFeature`` (single). Redefines ``Subsetting::subsettingFeature``." + redefiningFeature = redefining_feature + + +class ReferenceSubsetting(Subsetting): + "Metaclass ``ReferenceSubsetting``." + __slots__ = () + METACLASS: ClassVar[str] = "ReferenceSubsetting" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Subsetting.JSON_KEYS, + "referencedFeature": "referenced_feature", + "referencingFeature": "referencing_feature", + }) + referenced_feature: Opt[Feature] = Opt("referencedFeature", "Feature") + "``ReferenceSubsetting::referencedFeature`` (single). Redefines ``Subsetting::subsettedFeature``." + referencedFeature = referenced_feature + referencing_feature: Opt[Feature] = Opt("referencingFeature", "Feature", derived=True) + "``ReferenceSubsetting::referencingFeature`` (single, derived). Redefines ``Subsetting::owningFeature``, ``Subsetting::subsettingFeature``." + referencingFeature = referencing_feature + + +class TextualRepresentation(AnnotatingElement): + "Metaclass ``TextualRepresentation``." + __slots__ = () + METACLASS: ClassVar[str] = "TextualRepresentation" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **AnnotatingElement.JSON_KEYS, + "body": "body", + "language": "language", + "representedElement": "represented_element", + }) + body: Opt[str] = Opt("body", "str") + "``TextualRepresentation::body`` (single)." + language: Opt[str] = Opt("language", "str") + "``TextualRepresentation::language`` (single)." + represented_element: Opt[Element] = Opt("representedElement", "Element", derived=True) + "``TextualRepresentation::representedElement`` (single, derived). Redefines ``AnnotatingElement::annotatedElement``." + representedElement = represented_element + + +class TransitionFeatureMembership(FeatureMembership): + "Metaclass ``TransitionFeatureMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "TransitionFeatureMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **FeatureMembership.JSON_KEYS, + "kind": "kind", + "transitionFeature": "transition_feature", + }) + kind: Opt[TransitionFeatureKind] = Opt("kind", "TransitionFeatureKind") + "``TransitionFeatureMembership::kind`` (single)." + transition_feature: Opt[Step] = Opt("transitionFeature", "Step", derived=True) + "``TransitionFeatureMembership::transitionFeature`` (single, derived). Redefines ``FeatureMembership::ownedMemberFeature``." + transitionFeature = transition_feature + + +class Type(Namespace): + "Metaclass ``Type``." + __slots__ = () + METACLASS: ClassVar[str] = "Type" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Namespace.JSON_KEYS, + "differencingType": "differencing_type", + "directedFeature": "directed_feature", + "endFeature": "end_feature", + "feature": "feature", + "featureMembership": "feature_membership", + "inheritedFeature": "inherited_feature", + "inheritedMembership": "inherited_membership", + "input": "input", + "intersectingType": "intersecting_type", + "isAbstract": "is_abstract", + "isConjugated": "is_conjugated", + "isSufficient": "is_sufficient", + "multiplicity": "multiplicity", + "output": "output", + "ownedConjugator": "owned_conjugator", + "ownedDifferencing": "owned_differencing", + "ownedDisjoining": "owned_disjoining", + "ownedEndFeature": "owned_end_feature", + "ownedFeature": "owned_feature", + "ownedFeatureMembership": "owned_feature_membership", + "ownedIntersecting": "owned_intersecting", + "ownedSpecialization": "owned_specialization", + "ownedUnioning": "owned_unioning", + "unioningType": "unioning_type", + }) + differencing_type: Many[Type] = Many("differencingType", "Type", ordered=True, derived=True) + "``Type::differencingType`` (many, ordered, derived)." + differencingType = differencing_type + directed_feature: Many[Feature] = Many("directedFeature", "Feature", ordered=True, derived=True) + "``Type::directedFeature`` (many, ordered, derived)." + directedFeature = directed_feature + end_feature: Many[Feature] = Many("endFeature", "Feature", ordered=True, derived=True) + "``Type::endFeature`` (many, ordered, derived)." + endFeature = end_feature + feature: Many[Feature] = Many("feature", "Feature", ordered=True, derived=True) + "``Type::feature`` (many, ordered, derived)." + feature_membership: Many[FeatureMembership] = Many("featureMembership", "FeatureMembership", ordered=True, derived=True) + "``Type::featureMembership`` (many, ordered, derived)." + featureMembership = feature_membership + inherited_feature: Many[Feature] = Many("inheritedFeature", "Feature", ordered=True, derived=True) + "``Type::inheritedFeature`` (many, ordered, derived)." + inheritedFeature = inherited_feature + inherited_membership: Many[Membership] = Many("inheritedMembership", "Membership", ordered=True, derived=True) + "``Type::inheritedMembership`` (many, ordered, derived)." + inheritedMembership = inherited_membership + input: Many[Feature] = Many("input", "Feature", ordered=True, derived=True) + "``Type::input`` (many, ordered, derived)." + intersecting_type: Many[Type] = Many("intersectingType", "Type", ordered=True, derived=True) + "``Type::intersectingType`` (many, ordered, derived)." + intersectingType = intersecting_type + is_abstract: Opt[bool] = Opt("isAbstract", "bool") + "``Type::isAbstract`` (single)." + isAbstract = is_abstract + is_conjugated: Opt[bool] = Opt("isConjugated", "bool", derived=True) + "``Type::isConjugated`` (single, derived)." + isConjugated = is_conjugated + is_sufficient: Opt[bool] = Opt("isSufficient", "bool") + "``Type::isSufficient`` (single)." + isSufficient = is_sufficient + multiplicity: Opt[Multiplicity] = Opt("multiplicity", "Multiplicity", derived=True) + "``Type::multiplicity`` (single, derived)." + output: Many[Feature] = Many("output", "Feature", ordered=True, derived=True) + "``Type::output`` (many, ordered, derived)." + owned_conjugator: Opt[Conjugation] = Opt("ownedConjugator", "Conjugation", derived=True) + "``Type::ownedConjugator`` (single, derived)." + ownedConjugator = owned_conjugator + owned_differencing: Many[Differencing] = Many("ownedDifferencing", "Differencing", ordered=True, derived=True) + "``Type::ownedDifferencing`` (many, ordered, derived)." + ownedDifferencing = owned_differencing + owned_disjoining: Many[Disjoining] = Many("ownedDisjoining", "Disjoining", ordered=False, derived=True) + "``Type::ownedDisjoining`` (many, derived)." + ownedDisjoining = owned_disjoining + owned_end_feature: Many[Feature] = Many("ownedEndFeature", "Feature", ordered=True, derived=True) + "``Type::ownedEndFeature`` (many, ordered, derived)." + ownedEndFeature = owned_end_feature + owned_feature: Many[Feature] = Many("ownedFeature", "Feature", ordered=True, derived=True) + "``Type::ownedFeature`` (many, ordered, derived)." + ownedFeature = owned_feature + owned_feature_membership: Many[FeatureMembership] = Many("ownedFeatureMembership", "FeatureMembership", ordered=True, derived=True) + "``Type::ownedFeatureMembership`` (many, ordered, derived)." + ownedFeatureMembership = owned_feature_membership + owned_intersecting: Many[Intersecting] = Many("ownedIntersecting", "Intersecting", ordered=True, derived=True) + "``Type::ownedIntersecting`` (many, ordered, derived)." + ownedIntersecting = owned_intersecting + owned_specialization: Many[Specialization] = Many("ownedSpecialization", "Specialization", ordered=True, derived=True) + "``Type::ownedSpecialization`` (many, ordered, derived)." + ownedSpecialization = owned_specialization + owned_unioning: Many[Unioning] = Many("ownedUnioning", "Unioning", ordered=True, derived=True) + "``Type::ownedUnioning`` (many, ordered, derived)." + ownedUnioning = owned_unioning + unioning_type: Many[Type] = Many("unioningType", "Type", ordered=True, derived=True) + "``Type::unioningType`` (many, ordered, derived)." + unioningType = unioning_type + + +class Classifier(Type): + "Metaclass ``Classifier``." + __slots__ = () + METACLASS: ClassVar[str] = "Classifier" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Type.JSON_KEYS, + "ownedSubclassification": "owned_subclassification", + }) + owned_subclassification: Many[Subclassification] = Many("ownedSubclassification", "Subclassification", ordered=False, derived=True) + "``Classifier::ownedSubclassification`` (many, derived)." + ownedSubclassification = owned_subclassification + + +class Association(Classifier, Relationship): + "Metaclass ``Association``." + __slots__ = () + METACLASS: ClassVar[str] = "Association" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + **Classifier.JSON_KEYS, + "associationEnd": "association_end", + "relatedType": "related_type", + "sourceType": "source_type", + "targetType": "target_type", + }) + association_end: Many[Feature] = Many("associationEnd", "Feature", ordered=False, derived=True) + "``Association::associationEnd`` (many, derived). Redefines ``Type::endFeature``." + associationEnd = association_end + related_type: Many[Type] = Many("relatedType", "Type", ordered=True, derived=True) + "``Association::relatedType`` (many, ordered, derived). Redefines ``Relationship::relatedElement``." + relatedType = related_type + source_type: Opt[Type] = Opt("sourceType", "Type", derived=True) + "``Association::sourceType`` (single, derived). Redefines ``Relationship::source``." + sourceType = source_type + target_type: Many[Type] = Many("targetType", "Type", ordered=False, derived=True) + "``Association::targetType`` (many, derived). Redefines ``Relationship::target``." + targetType = target_type + + +class Class(Classifier): + "Metaclass ``Class``." + __slots__ = () + METACLASS: ClassVar[str] = "Class" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Classifier.JSON_KEYS, + }) + + +class Behavior(Class): + "Metaclass ``Behavior``." + __slots__ = () + METACLASS: ClassVar[str] = "Behavior" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Class.JSON_KEYS, + "parameter": "parameter", + "step": "step", + }) + parameter: Many[Feature] = Many("parameter", "Feature", ordered=True, derived=True) + "``Behavior::parameter`` (many, ordered, derived). Redefines ``Type::directedFeature``." + step: Many[Step] = Many("step", "Step", ordered=False, derived=True) + "``Behavior::step`` (many, derived)." + + +class DataType(Classifier): + "Metaclass ``DataType``." + __slots__ = () + METACLASS: ClassVar[str] = "DataType" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Classifier.JSON_KEYS, + }) + + +class Definition(Classifier): + "Metaclass ``Definition``." + __slots__ = () + METACLASS: ClassVar[str] = "Definition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Classifier.JSON_KEYS, + "directedUsage": "directed_usage", + "isVariation": "is_variation", + "ownedAction": "owned_action", + "ownedAllocation": "owned_allocation", + "ownedAnalysisCase": "owned_analysis_case", + "ownedAttribute": "owned_attribute", + "ownedCalculation": "owned_calculation", + "ownedCase": "owned_case", + "ownedConcern": "owned_concern", + "ownedConnection": "owned_connection", + "ownedConstraint": "owned_constraint", + "ownedEnumeration": "owned_enumeration", + "ownedFlow": "owned_flow", + "ownedInterface": "owned_interface", + "ownedItem": "owned_item", + "ownedMetadata": "owned_metadata", + "ownedOccurrence": "owned_occurrence", + "ownedPart": "owned_part", + "ownedPort": "owned_port", + "ownedReference": "owned_reference", + "ownedRendering": "owned_rendering", + "ownedRequirement": "owned_requirement", + "ownedState": "owned_state", + "ownedTransition": "owned_transition", + "ownedUsage": "owned_usage", + "ownedUseCase": "owned_use_case", + "ownedVerificationCase": "owned_verification_case", + "ownedView": "owned_view", + "ownedViewpoint": "owned_viewpoint", + "usage": "usage", + "variant": "variant", + "variantMembership": "variant_membership", + }) + directed_usage: Many[Usage] = Many("directedUsage", "Usage", ordered=True, derived=True) + "``Definition::directedUsage`` (many, ordered, derived)." + directedUsage = directed_usage + is_variation: Opt[bool] = Opt("isVariation", "bool") + "``Definition::isVariation`` (single)." + isVariation = is_variation + owned_action: Many[ActionUsage] = Many("ownedAction", "ActionUsage", ordered=True, derived=True) + "``Definition::ownedAction`` (many, ordered, derived)." + ownedAction = owned_action + owned_allocation: Many[AllocationUsage] = Many("ownedAllocation", "AllocationUsage", ordered=True, derived=True) + "``Definition::ownedAllocation`` (many, ordered, derived)." + ownedAllocation = owned_allocation + owned_analysis_case: Many[AnalysisCaseUsage] = Many("ownedAnalysisCase", "AnalysisCaseUsage", ordered=True, derived=True) + "``Definition::ownedAnalysisCase`` (many, ordered, derived)." + ownedAnalysisCase = owned_analysis_case + owned_attribute: Many[AttributeUsage] = Many("ownedAttribute", "AttributeUsage", ordered=True, derived=True) + "``Definition::ownedAttribute`` (many, ordered, derived)." + ownedAttribute = owned_attribute + owned_calculation: Many[CalculationUsage] = Many("ownedCalculation", "CalculationUsage", ordered=True, derived=True) + "``Definition::ownedCalculation`` (many, ordered, derived)." + ownedCalculation = owned_calculation + owned_case: Many[CaseUsage] = Many("ownedCase", "CaseUsage", ordered=True, derived=True) + "``Definition::ownedCase`` (many, ordered, derived)." + ownedCase = owned_case + owned_concern: Many[ConcernUsage] = Many("ownedConcern", "ConcernUsage", ordered=False, derived=True) + "``Definition::ownedConcern`` (many, derived)." + ownedConcern = owned_concern + owned_connection: Many[ConnectorAsUsage] = Many("ownedConnection", "ConnectorAsUsage", ordered=True, derived=True) + "``Definition::ownedConnection`` (many, ordered, derived)." + ownedConnection = owned_connection + owned_constraint: Many[ConstraintUsage] = Many("ownedConstraint", "ConstraintUsage", ordered=True, derived=True) + "``Definition::ownedConstraint`` (many, ordered, derived)." + ownedConstraint = owned_constraint + owned_enumeration: Many[EnumerationUsage] = Many("ownedEnumeration", "EnumerationUsage", ordered=True, derived=True) + "``Definition::ownedEnumeration`` (many, ordered, derived)." + ownedEnumeration = owned_enumeration + owned_flow: Many[FlowUsage] = Many("ownedFlow", "FlowUsage", ordered=False, derived=True) + "``Definition::ownedFlow`` (many, derived)." + ownedFlow = owned_flow + owned_interface: Many[InterfaceUsage] = Many("ownedInterface", "InterfaceUsage", ordered=True, derived=True) + "``Definition::ownedInterface`` (many, ordered, derived)." + ownedInterface = owned_interface + owned_item: Many[ItemUsage] = Many("ownedItem", "ItemUsage", ordered=True, derived=True) + "``Definition::ownedItem`` (many, ordered, derived)." + ownedItem = owned_item + owned_metadata: Many[MetadataUsage] = Many("ownedMetadata", "MetadataUsage", ordered=True, derived=True) + "``Definition::ownedMetadata`` (many, ordered, derived)." + ownedMetadata = owned_metadata + owned_occurrence: Many[OccurrenceUsage] = Many("ownedOccurrence", "OccurrenceUsage", ordered=True, derived=True) + "``Definition::ownedOccurrence`` (many, ordered, derived)." + ownedOccurrence = owned_occurrence + owned_part: Many[PartUsage] = Many("ownedPart", "PartUsage", ordered=True, derived=True) + "``Definition::ownedPart`` (many, ordered, derived)." + ownedPart = owned_part + owned_port: Many[PortUsage] = Many("ownedPort", "PortUsage", ordered=True, derived=True) + "``Definition::ownedPort`` (many, ordered, derived)." + ownedPort = owned_port + owned_reference: Many[ReferenceUsage] = Many("ownedReference", "ReferenceUsage", ordered=True, derived=True) + "``Definition::ownedReference`` (many, ordered, derived)." + ownedReference = owned_reference + owned_rendering: Many[RenderingUsage] = Many("ownedRendering", "RenderingUsage", ordered=True, derived=True) + "``Definition::ownedRendering`` (many, ordered, derived)." + ownedRendering = owned_rendering + owned_requirement: Many[RequirementUsage] = Many("ownedRequirement", "RequirementUsage", ordered=True, derived=True) + "``Definition::ownedRequirement`` (many, ordered, derived)." + ownedRequirement = owned_requirement + owned_state: Many[StateUsage] = Many("ownedState", "StateUsage", ordered=True, derived=True) + "``Definition::ownedState`` (many, ordered, derived)." + ownedState = owned_state + owned_transition: Many[TransitionUsage] = Many("ownedTransition", "TransitionUsage", ordered=False, derived=True) + "``Definition::ownedTransition`` (many, derived)." + ownedTransition = owned_transition + owned_usage: Many[Usage] = Many("ownedUsage", "Usage", ordered=True, derived=True) + "``Definition::ownedUsage`` (many, ordered, derived)." + ownedUsage = owned_usage + owned_use_case: Many[UseCaseUsage] = Many("ownedUseCase", "UseCaseUsage", ordered=True, derived=True) + "``Definition::ownedUseCase`` (many, ordered, derived)." + ownedUseCase = owned_use_case + owned_verification_case: Many[VerificationCaseUsage] = Many("ownedVerificationCase", "VerificationCaseUsage", ordered=True, derived=True) + "``Definition::ownedVerificationCase`` (many, ordered, derived)." + ownedVerificationCase = owned_verification_case + owned_view: Many[ViewUsage] = Many("ownedView", "ViewUsage", ordered=True, derived=True) + "``Definition::ownedView`` (many, ordered, derived)." + ownedView = owned_view + owned_viewpoint: Many[ViewpointUsage] = Many("ownedViewpoint", "ViewpointUsage", ordered=True, derived=True) + "``Definition::ownedViewpoint`` (many, ordered, derived)." + ownedViewpoint = owned_viewpoint + usage: Many[Usage] = Many("usage", "Usage", ordered=True, derived=True) + "``Definition::usage`` (many, ordered, derived)." + variant: Many[Usage] = Many("variant", "Usage", ordered=False, derived=True) + "``Definition::variant`` (many, derived)." + variant_membership: Many[VariantMembership] = Many("variantMembership", "VariantMembership", ordered=False, derived=True) + "``Definition::variantMembership`` (many, derived)." + variantMembership = variant_membership + + +class AttributeDefinition(DataType, Definition): + "Metaclass ``AttributeDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "AttributeDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Definition.JSON_KEYS, + **DataType.JSON_KEYS, + }) + + +class EnumerationDefinition(AttributeDefinition): + "Metaclass ``EnumerationDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "EnumerationDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **AttributeDefinition.JSON_KEYS, + "enumeratedValue": "enumerated_value", + }) + enumerated_value: Many[EnumerationUsage] = Many("enumeratedValue", "EnumerationUsage", ordered=True, derived=True) + "``EnumerationDefinition::enumeratedValue`` (many, ordered, derived). Redefines ``Definition::variant``." + enumeratedValue = enumerated_value + + +class Feature(Type): + "Metaclass ``Feature``." + __slots__ = () + METACLASS: ClassVar[str] = "Feature" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Type.JSON_KEYS, + "chainingFeature": "chaining_feature", + "crossFeature": "cross_feature", + "direction": "direction", + "endOwningType": "end_owning_type", + "featureTarget": "feature_target", + "featuringType": "featuring_type", + "isComposite": "is_composite", + "isConstant": "is_constant", + "isDerived": "is_derived", + "isEnd": "is_end", + "isOrdered": "is_ordered", + "isPortion": "is_portion", + "isUnique": "is_unique", + "isVariable": "is_variable", + "ownedCrossSubsetting": "owned_cross_subsetting", + "ownedFeatureChaining": "owned_feature_chaining", + "ownedFeatureInverting": "owned_feature_inverting", + "ownedRedefinition": "owned_redefinition", + "ownedReferenceSubsetting": "owned_reference_subsetting", + "ownedSubsetting": "owned_subsetting", + "ownedTypeFeaturing": "owned_type_featuring", + "ownedTyping": "owned_typing", + "owningFeatureMembership": "owning_feature_membership", + "owningType": "owning_type", + "type": "type", + }) + chaining_feature: Many[Feature] = Many("chainingFeature", "Feature", ordered=True, derived=True) + "``Feature::chainingFeature`` (many, ordered, derived)." + chainingFeature = chaining_feature + cross_feature: Opt[Feature] = Opt("crossFeature", "Feature", derived=True) + "``Feature::crossFeature`` (single, derived)." + crossFeature = cross_feature + direction: Opt[FeatureDirectionKind] = Opt("direction", "FeatureDirectionKind") + "``Feature::direction`` (single)." + end_owning_type: Opt[Type] = Opt("endOwningType", "Type", derived=True) + "``Feature::endOwningType`` (single, derived)." + endOwningType = end_owning_type + feature_target: Opt[Feature] = Opt("featureTarget", "Feature", derived=True) + "``Feature::featureTarget`` (single, derived)." + featureTarget = feature_target + featuring_type: Many[Type] = Many("featuringType", "Type", ordered=True, derived=True) + "``Feature::featuringType`` (many, ordered, derived)." + featuringType = featuring_type + is_composite: Opt[bool] = Opt("isComposite", "bool") + "``Feature::isComposite`` (single)." + isComposite = is_composite + is_constant: Opt[bool] = Opt("isConstant", "bool") + "``Feature::isConstant`` (single)." + isConstant = is_constant + is_derived: Opt[bool] = Opt("isDerived", "bool") + "``Feature::isDerived`` (single)." + isDerived = is_derived + is_end: Opt[bool] = Opt("isEnd", "bool") + "``Feature::isEnd`` (single)." + isEnd = is_end + is_ordered: Opt[bool] = Opt("isOrdered", "bool") + "``Feature::isOrdered`` (single)." + isOrdered = is_ordered + is_portion: Opt[bool] = Opt("isPortion", "bool") + "``Feature::isPortion`` (single)." + isPortion = is_portion + is_unique: Opt[bool] = Opt("isUnique", "bool") + "``Feature::isUnique`` (single)." + isUnique = is_unique + is_variable: Opt[bool] = Opt("isVariable", "bool") + "``Feature::isVariable`` (single)." + isVariable = is_variable + owned_cross_subsetting: Opt[CrossSubsetting] = Opt("ownedCrossSubsetting", "CrossSubsetting", derived=True) + "``Feature::ownedCrossSubsetting`` (single, derived)." + ownedCrossSubsetting = owned_cross_subsetting + owned_feature_chaining: Many[FeatureChaining] = Many("ownedFeatureChaining", "FeatureChaining", ordered=True, derived=True) + "``Feature::ownedFeatureChaining`` (many, ordered, derived)." + ownedFeatureChaining = owned_feature_chaining + owned_feature_inverting: Many[FeatureInverting] = Many("ownedFeatureInverting", "FeatureInverting", ordered=False, derived=True) + "``Feature::ownedFeatureInverting`` (many, derived)." + ownedFeatureInverting = owned_feature_inverting + owned_redefinition: Many[Redefinition] = Many("ownedRedefinition", "Redefinition", ordered=False, derived=True) + "``Feature::ownedRedefinition`` (many, derived)." + ownedRedefinition = owned_redefinition + owned_reference_subsetting: Opt[ReferenceSubsetting] = Opt("ownedReferenceSubsetting", "ReferenceSubsetting", derived=True) + "``Feature::ownedReferenceSubsetting`` (single, derived)." + ownedReferenceSubsetting = owned_reference_subsetting + owned_subsetting: Many[Subsetting] = Many("ownedSubsetting", "Subsetting", ordered=False, derived=True) + "``Feature::ownedSubsetting`` (many, derived)." + ownedSubsetting = owned_subsetting + owned_type_featuring: Many[TypeFeaturing] = Many("ownedTypeFeaturing", "TypeFeaturing", ordered=True, derived=True) + "``Feature::ownedTypeFeaturing`` (many, ordered, derived)." + ownedTypeFeaturing = owned_type_featuring + owned_typing: Many[FeatureTyping] = Many("ownedTyping", "FeatureTyping", ordered=True, derived=True) + "``Feature::ownedTyping`` (many, ordered, derived)." + ownedTyping = owned_typing + owning_feature_membership: Opt[FeatureMembership] = Opt("owningFeatureMembership", "FeatureMembership", derived=True) + "``Feature::owningFeatureMembership`` (single, derived)." + owningFeatureMembership = owning_feature_membership + owning_type: Opt[Type] = Opt("owningType", "Type", derived=True) + "``Feature::owningType`` (single, derived)." + owningType = owning_type + type: Many[Type] = Many("type", "Type", ordered=True, derived=True) + "``Feature::type`` (many, ordered, derived)." + + +class Connector(Feature, Relationship): + "Metaclass ``Connector``." + __slots__ = () + METACLASS: ClassVar[str] = "Connector" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + **Feature.JSON_KEYS, + "association": "association", + "connectorEnd": "connector_end", + "defaultFeaturingType": "default_featuring_type", + "relatedFeature": "related_feature", + "sourceFeature": "source_feature", + "targetFeature": "target_feature", + }) + association: Many[Association] = Many("association", "Association", ordered=True, derived=True) + "``Connector::association`` (many, ordered, derived). Redefines ``Feature::type``." + connector_end: Many[Feature] = Many("connectorEnd", "Feature", ordered=True, derived=True) + "``Connector::connectorEnd`` (many, ordered, derived). Redefines ``Type::endFeature``." + connectorEnd = connector_end + default_featuring_type: Opt[Type] = Opt("defaultFeaturingType", "Type", derived=True) + "``Connector::defaultFeaturingType`` (single, derived)." + defaultFeaturingType = default_featuring_type + related_feature: Many[Feature] = Many("relatedFeature", "Feature", ordered=True, derived=True) + "``Connector::relatedFeature`` (many, ordered, derived). Redefines ``Relationship::relatedElement``." + relatedFeature = related_feature + source_feature: Opt[Feature] = Opt("sourceFeature", "Feature", derived=True) + "``Connector::sourceFeature`` (single, derived). Redefines ``Relationship::source``." + sourceFeature = source_feature + target_feature: Many[Feature] = Many("targetFeature", "Feature", ordered=True, derived=True) + "``Connector::targetFeature`` (many, ordered, derived). Redefines ``Relationship::target``." + targetFeature = target_feature + + +class BindingConnector(Connector): + "Metaclass ``BindingConnector``." + __slots__ = () + METACLASS: ClassVar[str] = "BindingConnector" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Connector.JSON_KEYS, + }) + + +class FlowEnd(Feature): + "Metaclass ``FlowEnd``." + __slots__ = () + METACLASS: ClassVar[str] = "FlowEnd" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Feature.JSON_KEYS, + }) + + +class Function(Behavior): + "Metaclass ``Function``." + __slots__ = () + METACLASS: ClassVar[str] = "Function" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Behavior.JSON_KEYS, + "expression": "expression", + "isModelLevelEvaluable": "is_model_level_evaluable", + "result": "result", + }) + expression: Many[Expression] = Many("expression", "Expression", ordered=False, derived=True) + "``Function::expression`` (many, derived)." + is_model_level_evaluable: Opt[bool] = Opt("isModelLevelEvaluable", "bool", derived=True) + "``Function::isModelLevelEvaluable`` (single, derived)." + isModelLevelEvaluable = is_model_level_evaluable + result: Opt[Feature] = Opt("result", "Feature", derived=True) + "``Function::result`` (single, derived)." + + +class Interaction(Association, Behavior): + "Metaclass ``Interaction``." + __slots__ = () + METACLASS: ClassVar[str] = "Interaction" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Behavior.JSON_KEYS, + **Association.JSON_KEYS, + }) + + +class MetadataFeature(AnnotatingElement, Feature): + "Metaclass ``MetadataFeature``." + __slots__ = () + METACLASS: ClassVar[str] = "MetadataFeature" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Feature.JSON_KEYS, + **AnnotatingElement.JSON_KEYS, + "metaclass": "metaclass", + }) + metaclass: Opt[Metaclass] = Opt("metaclass", "Metaclass", derived=True) + "``MetadataFeature::metaclass`` (single, derived)." + + +class Multiplicity(Feature): + "Metaclass ``Multiplicity``." + __slots__ = () + METACLASS: ClassVar[str] = "Multiplicity" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Feature.JSON_KEYS, + }) + + +class MultiplicityRange(Multiplicity): + "Metaclass ``MultiplicityRange``." + __slots__ = () + METACLASS: ClassVar[str] = "MultiplicityRange" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Multiplicity.JSON_KEYS, + "bound": "bound", + "lowerBound": "lower_bound", + "upperBound": "upper_bound", + }) + bound: Many[Expression] = Many("bound", "Expression", ordered=True, derived=True) + "``MultiplicityRange::bound`` (many, ordered, derived)." + lower_bound: Opt[Expression] = Opt("lowerBound", "Expression", derived=True) + "``MultiplicityRange::lowerBound`` (single, derived)." + lowerBound = lower_bound + upper_bound: Opt[Expression] = Opt("upperBound", "Expression", derived=True) + "``MultiplicityRange::upperBound`` (single, derived)." + upperBound = upper_bound + + +class OccurrenceDefinition(Class, Definition): + "Metaclass ``OccurrenceDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "OccurrenceDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Definition.JSON_KEYS, + **Class.JSON_KEYS, + "isIndividual": "is_individual", + }) + is_individual: Opt[bool] = Opt("isIndividual", "bool") + "``OccurrenceDefinition::isIndividual`` (single)." + isIndividual = is_individual + + +class ActionDefinition(Behavior, OccurrenceDefinition): + "Metaclass ``ActionDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "ActionDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OccurrenceDefinition.JSON_KEYS, + **Behavior.JSON_KEYS, + "action": "action", + }) + action: Many[ActionUsage] = Many("action", "ActionUsage", ordered=True, derived=True) + "``ActionDefinition::action`` (many, ordered, derived)." + + +class CalculationDefinition(ActionDefinition, Function): + "Metaclass ``CalculationDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "CalculationDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Function.JSON_KEYS, + **ActionDefinition.JSON_KEYS, + "calculation": "calculation", + }) + calculation: Many[CalculationUsage] = Many("calculation", "CalculationUsage", ordered=True, derived=True) + "``CalculationDefinition::calculation`` (many, ordered, derived)." + + +class CaseDefinition(CalculationDefinition): + "Metaclass ``CaseDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "CaseDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **CalculationDefinition.JSON_KEYS, + "actorParameter": "actor_parameter", + "objectiveRequirement": "objective_requirement", + "subjectParameter": "subject_parameter", + }) + actor_parameter: Many[PartUsage] = Many("actorParameter", "PartUsage", ordered=True, derived=True) + "``CaseDefinition::actorParameter`` (many, ordered, derived)." + actorParameter = actor_parameter + objective_requirement: Opt[RequirementUsage] = Opt("objectiveRequirement", "RequirementUsage", derived=True) + "``CaseDefinition::objectiveRequirement`` (single, derived)." + objectiveRequirement = objective_requirement + subject_parameter: Opt[Usage] = Opt("subjectParameter", "Usage", derived=True) + "``CaseDefinition::subjectParameter`` (single, derived)." + subjectParameter = subject_parameter + + +class AnalysisCaseDefinition(CaseDefinition): + "Metaclass ``AnalysisCaseDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "AnalysisCaseDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **CaseDefinition.JSON_KEYS, + "resultExpression": "result_expression", + }) + result_expression: Opt[Expression] = Opt("resultExpression", "Expression", derived=True) + "``AnalysisCaseDefinition::resultExpression`` (single, derived)." + resultExpression = result_expression + + +class FlowDefinition(ActionDefinition, Interaction): + "Metaclass ``FlowDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "FlowDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Interaction.JSON_KEYS, + **ActionDefinition.JSON_KEYS, + "flowEnd": "flow_end", + }) + flow_end: Many[Usage] = Many("flowEnd", "Usage", ordered=False, derived=True) + "``FlowDefinition::flowEnd`` (many, derived). Redefines ``Association::associationEnd``." + flowEnd = flow_end + + +class PayloadFeature(Feature): + "Metaclass ``PayloadFeature``." + __slots__ = () + METACLASS: ClassVar[str] = "PayloadFeature" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Feature.JSON_KEYS, + }) + + +class Predicate(Function): + "Metaclass ``Predicate``." + __slots__ = () + METACLASS: ClassVar[str] = "Predicate" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Function.JSON_KEYS, + }) + + +class ConstraintDefinition(OccurrenceDefinition, Predicate): + "Metaclass ``ConstraintDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "ConstraintDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Predicate.JSON_KEYS, + **OccurrenceDefinition.JSON_KEYS, + }) + + +class RequirementDefinition(ConstraintDefinition): + "Metaclass ``RequirementDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "RequirementDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ConstraintDefinition.JSON_KEYS, + "actorParameter": "actor_parameter", + "assumedConstraint": "assumed_constraint", + "framedConcern": "framed_concern", + "reqId": "req_id", + "requiredConstraint": "required_constraint", + "stakeholderParameter": "stakeholder_parameter", + "subjectParameter": "subject_parameter", + "text": "text", + }) + actor_parameter: Many[PartUsage] = Many("actorParameter", "PartUsage", ordered=True, derived=True) + "``RequirementDefinition::actorParameter`` (many, ordered, derived)." + actorParameter = actor_parameter + assumed_constraint: Many[ConstraintUsage] = Many("assumedConstraint", "ConstraintUsage", ordered=True, derived=True) + "``RequirementDefinition::assumedConstraint`` (many, ordered, derived)." + assumedConstraint = assumed_constraint + framed_concern: Many[ConcernUsage] = Many("framedConcern", "ConcernUsage", ordered=True, derived=True) + "``RequirementDefinition::framedConcern`` (many, ordered, derived)." + framedConcern = framed_concern + req_id: Opt[str] = Opt("reqId", "str") + "``RequirementDefinition::reqId`` (single). Redefines ``Element::declaredShortName``." + reqId = req_id + required_constraint: Many[ConstraintUsage] = Many("requiredConstraint", "ConstraintUsage", ordered=True, derived=True) + "``RequirementDefinition::requiredConstraint`` (many, ordered, derived)." + requiredConstraint = required_constraint + stakeholder_parameter: Many[PartUsage] = Many("stakeholderParameter", "PartUsage", ordered=True, derived=True) + "``RequirementDefinition::stakeholderParameter`` (many, ordered, derived)." + stakeholderParameter = stakeholder_parameter + subject_parameter: Opt[Usage] = Opt("subjectParameter", "Usage", derived=True) + "``RequirementDefinition::subjectParameter`` (single, derived)." + subjectParameter = subject_parameter + text: Many[str] = Many("text", "str", ordered=False, derived=True) + "``RequirementDefinition::text`` (many, derived)." + + +class ConcernDefinition(RequirementDefinition): + "Metaclass ``ConcernDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "ConcernDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **RequirementDefinition.JSON_KEYS, + }) + + +class StateDefinition(ActionDefinition): + "Metaclass ``StateDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "StateDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ActionDefinition.JSON_KEYS, + "doAction": "do_action", + "entryAction": "entry_action", + "exitAction": "exit_action", + "isParallel": "is_parallel", + "state": "state", + }) + do_action: Opt[ActionUsage] = Opt("doAction", "ActionUsage", derived=True) + "``StateDefinition::doAction`` (single, derived)." + doAction = do_action + entry_action: Opt[ActionUsage] = Opt("entryAction", "ActionUsage", derived=True) + "``StateDefinition::entryAction`` (single, derived)." + entryAction = entry_action + exit_action: Opt[ActionUsage] = Opt("exitAction", "ActionUsage", derived=True) + "``StateDefinition::exitAction`` (single, derived)." + exitAction = exit_action + is_parallel: Opt[bool] = Opt("isParallel", "bool") + "``StateDefinition::isParallel`` (single)." + isParallel = is_parallel + state: Many[StateUsage] = Many("state", "StateUsage", ordered=True, derived=True) + "``StateDefinition::state`` (many, ordered, derived)." + + +class Step(Feature): + "Metaclass ``Step``." + __slots__ = () + METACLASS: ClassVar[str] = "Step" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Feature.JSON_KEYS, + "behavior": "behavior", + "parameter": "parameter", + }) + behavior: Many[Behavior] = Many("behavior", "Behavior", ordered=True, derived=True) + "``Step::behavior`` (many, ordered, derived)." + parameter: Many[Feature] = Many("parameter", "Feature", ordered=True, derived=True) + "``Step::parameter`` (many, ordered, derived). Redefines ``Type::directedFeature``." + + +class Expression(Step): + "Metaclass ``Expression``." + __slots__ = () + METACLASS: ClassVar[str] = "Expression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Step.JSON_KEYS, + "function": "function", + "isModelLevelEvaluable": "is_model_level_evaluable", + "result": "result", + }) + function: Opt[Function] = Opt("function", "Function", derived=True) + "``Expression::function`` (single, derived). Redefines ``Step::behavior``." + is_model_level_evaluable: Opt[bool] = Opt("isModelLevelEvaluable", "bool", derived=True) + "``Expression::isModelLevelEvaluable`` (single, derived)." + isModelLevelEvaluable = is_model_level_evaluable + result: Opt[Feature] = Opt("result", "Feature", derived=True) + "``Expression::result`` (single, derived)." + + +class BooleanExpression(Expression): + "Metaclass ``BooleanExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "BooleanExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Expression.JSON_KEYS, + "predicate": "predicate", + }) + predicate: Opt[Predicate] = Opt("predicate", "Predicate", derived=True) + "``BooleanExpression::predicate`` (single, derived). Redefines ``Expression::function``." + + +class FeatureReferenceExpression(Expression): + "Metaclass ``FeatureReferenceExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "FeatureReferenceExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Expression.JSON_KEYS, + "referent": "referent", + }) + referent: Opt[Feature] = Opt("referent", "Feature", derived=True) + "``FeatureReferenceExpression::referent`` (single, derived)." + + +class Flow(Connector, Step): + "Metaclass ``Flow``." + __slots__ = () + METACLASS: ClassVar[str] = "Flow" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Step.JSON_KEYS, + **Connector.JSON_KEYS, + "flowEnd": "flow_end", + "interaction": "interaction", + "payloadFeature": "payload_feature", + "payloadType": "payload_type", + "sourceOutputFeature": "source_output_feature", + "targetInputFeature": "target_input_feature", + }) + flow_end: Many[FlowEnd] = Many("flowEnd", "FlowEnd", ordered=True, derived=True) + "``Flow::flowEnd`` (many, ordered, derived)." + flowEnd = flow_end + interaction: Many[Interaction] = Many("interaction", "Interaction", ordered=True, derived=True) + "``Flow::interaction`` (many, ordered, derived). Redefines ``Connector::association``, ``Step::behavior``." + payload_feature: Opt[PayloadFeature] = Opt("payloadFeature", "PayloadFeature", derived=True) + "``Flow::payloadFeature`` (single, derived)." + payloadFeature = payload_feature + payload_type: Many[Classifier] = Many("payloadType", "Classifier", ordered=True, derived=True) + "``Flow::payloadType`` (many, ordered, derived)." + payloadType = payload_type + source_output_feature: Opt[Feature] = Opt("sourceOutputFeature", "Feature", derived=True) + "``Flow::sourceOutputFeature`` (single, derived)." + sourceOutputFeature = source_output_feature + target_input_feature: Opt[Feature] = Opt("targetInputFeature", "Feature", derived=True) + "``Flow::targetInputFeature`` (single, derived)." + targetInputFeature = target_input_feature + + +class InstantiationExpression(Expression): + "Abstract metaclass ``InstantiationExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "InstantiationExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Expression.JSON_KEYS, + "argument": "argument", + "instantiatedType": "instantiated_type", + }) + argument: Many[Expression] = Many("argument", "Expression", ordered=True, derived=True) + "``InstantiationExpression::argument`` (many, ordered, derived)." + instantiated_type: Opt[Type] = Opt("instantiatedType", "Type", derived=True) + "``InstantiationExpression::instantiatedType`` (single, derived)." + instantiatedType = instantiated_type + + +class ConstructorExpression(InstantiationExpression): + "Metaclass ``ConstructorExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "ConstructorExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **InstantiationExpression.JSON_KEYS, + }) + + +class Invariant(BooleanExpression): + "Metaclass ``Invariant``." + __slots__ = () + METACLASS: ClassVar[str] = "Invariant" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **BooleanExpression.JSON_KEYS, + "isNegated": "is_negated", + }) + is_negated: Opt[bool] = Opt("isNegated", "bool") + "``Invariant::isNegated`` (single)." + isNegated = is_negated + + +class InvocationExpression(InstantiationExpression): + "Metaclass ``InvocationExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "InvocationExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **InstantiationExpression.JSON_KEYS, + "operand": "operand", + }) + operand: Many[Expression] = Many("operand", "Expression", ordered=True, derived=True) + "``InvocationExpression::operand`` (many, ordered, derived)." + + +class LiteralExpression(Expression): + "Metaclass ``LiteralExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "LiteralExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Expression.JSON_KEYS, + }) + + +class LiteralBoolean(LiteralExpression): + "Metaclass ``LiteralBoolean``." + __slots__ = () + METACLASS: ClassVar[str] = "LiteralBoolean" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **LiteralExpression.JSON_KEYS, + "value": "value", + }) + value: Opt[bool] = Opt("value", "bool") + "``LiteralBoolean::value`` (single)." + + +class LiteralInfinity(LiteralExpression): + "Metaclass ``LiteralInfinity``." + __slots__ = () + METACLASS: ClassVar[str] = "LiteralInfinity" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **LiteralExpression.JSON_KEYS, + }) + + +class LiteralInteger(LiteralExpression): + "Metaclass ``LiteralInteger``." + __slots__ = () + METACLASS: ClassVar[str] = "LiteralInteger" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **LiteralExpression.JSON_KEYS, + "value": "value", + }) + value: Opt[int] = Opt("value", "int") + "``LiteralInteger::value`` (single)." + + +class LiteralRational(LiteralExpression): + "Metaclass ``LiteralRational``." + __slots__ = () + METACLASS: ClassVar[str] = "LiteralRational" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **LiteralExpression.JSON_KEYS, + "value": "value", + }) + value: Opt[float] = Opt("value", "float") + "``LiteralRational::value`` (single)." + + +class LiteralString(LiteralExpression): + "Metaclass ``LiteralString``." + __slots__ = () + METACLASS: ClassVar[str] = "LiteralString" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **LiteralExpression.JSON_KEYS, + "value": "value", + }) + value: Opt[str] = Opt("value", "str") + "``LiteralString::value`` (single)." + + +class MetadataAccessExpression(Expression): + "Metaclass ``MetadataAccessExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "MetadataAccessExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Expression.JSON_KEYS, + "referencedElement": "referenced_element", + }) + referenced_element: Opt[Element] = Opt("referencedElement", "Element", derived=True) + "``MetadataAccessExpression::referencedElement`` (single, derived)." + referencedElement = referenced_element + + +class NullExpression(Expression): + "Metaclass ``NullExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "NullExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Expression.JSON_KEYS, + }) + + +class OperatorExpression(InvocationExpression): + "Metaclass ``OperatorExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "OperatorExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **InvocationExpression.JSON_KEYS, + "operator": "operator", + }) + operator: Opt[str] = Opt("operator", "str") + "``OperatorExpression::operator`` (single)." + + +class CollectExpression(OperatorExpression): + "Metaclass ``CollectExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "CollectExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OperatorExpression.JSON_KEYS, + }) + + +class FeatureChainExpression(OperatorExpression): + "Metaclass ``FeatureChainExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "FeatureChainExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OperatorExpression.JSON_KEYS, + "targetFeature": "target_feature", + }) + target_feature: Opt[Feature] = Opt("targetFeature", "Feature", derived=True) + "``FeatureChainExpression::targetFeature`` (single, derived)." + targetFeature = target_feature + + +class IndexExpression(OperatorExpression): + "Metaclass ``IndexExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "IndexExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OperatorExpression.JSON_KEYS, + }) + + +class SelectExpression(OperatorExpression): + "Metaclass ``SelectExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "SelectExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OperatorExpression.JSON_KEYS, + }) + + +class Structure(Class): + "Metaclass ``Structure``." + __slots__ = () + METACLASS: ClassVar[str] = "Structure" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Class.JSON_KEYS, + }) + + +class AssociationStructure(Association, Structure): + "Metaclass ``AssociationStructure``." + __slots__ = () + METACLASS: ClassVar[str] = "AssociationStructure" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Structure.JSON_KEYS, + **Association.JSON_KEYS, + }) + + +class ItemDefinition(OccurrenceDefinition, Structure): + "Metaclass ``ItemDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "ItemDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Structure.JSON_KEYS, + **OccurrenceDefinition.JSON_KEYS, + }) + + +class Metaclass(Structure): + "Metaclass ``Metaclass``." + __slots__ = () + METACLASS: ClassVar[str] = "Metaclass" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Structure.JSON_KEYS, + }) + + +class MetadataDefinition(ItemDefinition, Metaclass): + "Metaclass ``MetadataDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "MetadataDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Metaclass.JSON_KEYS, + **ItemDefinition.JSON_KEYS, + }) + + +class PartDefinition(ItemDefinition): + "Metaclass ``PartDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "PartDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ItemDefinition.JSON_KEYS, + }) + + +class ConnectionDefinition(AssociationStructure, PartDefinition): + "Metaclass ``ConnectionDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "ConnectionDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **PartDefinition.JSON_KEYS, + **AssociationStructure.JSON_KEYS, + "connectionEnd": "connection_end", + }) + connection_end: Many[Usage] = Many("connectionEnd", "Usage", ordered=True, derived=True) + "``ConnectionDefinition::connectionEnd`` (many, ordered, derived). Redefines ``Association::associationEnd``." + connectionEnd = connection_end + + +class AllocationDefinition(ConnectionDefinition): + "Metaclass ``AllocationDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "AllocationDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ConnectionDefinition.JSON_KEYS, + "allocation": "allocation", + }) + allocation: Many[AllocationUsage] = Many("allocation", "AllocationUsage", ordered=True, derived=True) + "``AllocationDefinition::allocation`` (many, ordered, derived)." + + +class InterfaceDefinition(ConnectionDefinition): + "Metaclass ``InterfaceDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "InterfaceDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ConnectionDefinition.JSON_KEYS, + "interfaceEnd": "interface_end", + }) + interface_end: Many[PortUsage] = Many("interfaceEnd", "PortUsage", ordered=True, derived=True) + "``InterfaceDefinition::interfaceEnd`` (many, ordered, derived). Redefines ``ConnectionDefinition::connectionEnd``." + interfaceEnd = interface_end + + +class PortDefinition(OccurrenceDefinition, Structure): + "Metaclass ``PortDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "PortDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Structure.JSON_KEYS, + **OccurrenceDefinition.JSON_KEYS, + "conjugatedPortDefinition": "conjugated_port_definition", + }) + conjugated_port_definition: Opt[ConjugatedPortDefinition] = Opt("conjugatedPortDefinition", "ConjugatedPortDefinition", derived=True) + "``PortDefinition::conjugatedPortDefinition`` (single, derived)." + conjugatedPortDefinition = conjugated_port_definition + + +class ConjugatedPortDefinition(PortDefinition): + "Metaclass ``ConjugatedPortDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "ConjugatedPortDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **PortDefinition.JSON_KEYS, + "originalPortDefinition": "original_port_definition", + "ownedPortConjugator": "owned_port_conjugator", + }) + original_port_definition: Opt[PortDefinition] = Opt("originalPortDefinition", "PortDefinition", derived=True) + "``ConjugatedPortDefinition::originalPortDefinition`` (single, derived). Redefines ``Element::owningNamespace``." + originalPortDefinition = original_port_definition + owned_port_conjugator: Opt[PortConjugation] = Opt("ownedPortConjugator", "PortConjugation", derived=True) + "``ConjugatedPortDefinition::ownedPortConjugator`` (single, derived). Redefines ``Type::ownedConjugator``." + ownedPortConjugator = owned_port_conjugator + + +class RenderingDefinition(PartDefinition): + "Metaclass ``RenderingDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "RenderingDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **PartDefinition.JSON_KEYS, + "rendering": "rendering", + }) + rendering: Many[RenderingUsage] = Many("rendering", "RenderingUsage", ordered=True, derived=True) + "``RenderingDefinition::rendering`` (many, ordered, derived)." + + +class Succession(Connector): + "Metaclass ``Succession``." + __slots__ = () + METACLASS: ClassVar[str] = "Succession" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Connector.JSON_KEYS, + }) + + +class SuccessionFlow(Flow, Succession): + "Metaclass ``SuccessionFlow``." + __slots__ = () + METACLASS: ClassVar[str] = "SuccessionFlow" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Succession.JSON_KEYS, + **Flow.JSON_KEYS, + }) + + +class TriggerInvocationExpression(InvocationExpression): + "Metaclass ``TriggerInvocationExpression``." + __slots__ = () + METACLASS: ClassVar[str] = "TriggerInvocationExpression" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **InvocationExpression.JSON_KEYS, + "kind": "kind", + }) + kind: Opt[TriggerKind] = Opt("kind", "TriggerKind") + "``TriggerInvocationExpression::kind`` (single)." + + +class TypeFeaturing(Relationship): + "Metaclass ``TypeFeaturing``." + __slots__ = () + METACLASS: ClassVar[str] = "TypeFeaturing" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "featureOfType": "feature_of_type", + "featuringType": "featuring_type", + "owningFeatureOfType": "owning_feature_of_type", + }) + feature_of_type: Opt[Feature] = Opt("featureOfType", "Feature") + "``TypeFeaturing::featureOfType`` (single). Redefines ``Relationship::source``." + featureOfType = feature_of_type + featuring_type: Opt[Type] = Opt("featuringType", "Type") + "``TypeFeaturing::featuringType`` (single). Redefines ``Relationship::target``." + featuringType = featuring_type + owning_feature_of_type: Opt[Feature] = Opt("owningFeatureOfType", "Feature", derived=True) + "``TypeFeaturing::owningFeatureOfType`` (single, derived)." + owningFeatureOfType = owning_feature_of_type + + +class Unioning(Relationship): + "Metaclass ``Unioning``." + __slots__ = () + METACLASS: ClassVar[str] = "Unioning" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Relationship.JSON_KEYS, + "typeUnioned": "type_unioned", + "unioningType": "unioning_type", + }) + type_unioned: Opt[Type] = Opt("typeUnioned", "Type", derived=True) + "``Unioning::typeUnioned`` (single, derived). Redefines ``Relationship::source``." + typeUnioned = type_unioned + unioning_type: Opt[Type] = Opt("unioningType", "Type") + "``Unioning::unioningType`` (single). Redefines ``Relationship::target``." + unioningType = unioning_type + + +class Usage(Feature): + "Metaclass ``Usage``." + __slots__ = () + METACLASS: ClassVar[str] = "Usage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Feature.JSON_KEYS, + "definition": "definition", + "directedUsage": "directed_usage", + "isReference": "is_reference", + "isVariation": "is_variation", + "mayTimeVary": "may_time_vary", + "nestedAction": "nested_action", + "nestedAllocation": "nested_allocation", + "nestedAnalysisCase": "nested_analysis_case", + "nestedAttribute": "nested_attribute", + "nestedCalculation": "nested_calculation", + "nestedCase": "nested_case", + "nestedConcern": "nested_concern", + "nestedConnection": "nested_connection", + "nestedConstraint": "nested_constraint", + "nestedEnumeration": "nested_enumeration", + "nestedFlow": "nested_flow", + "nestedInterface": "nested_interface", + "nestedItem": "nested_item", + "nestedMetadata": "nested_metadata", + "nestedOccurrence": "nested_occurrence", + "nestedPart": "nested_part", + "nestedPort": "nested_port", + "nestedReference": "nested_reference", + "nestedRendering": "nested_rendering", + "nestedRequirement": "nested_requirement", + "nestedState": "nested_state", + "nestedTransition": "nested_transition", + "nestedUsage": "nested_usage", + "nestedUseCase": "nested_use_case", + "nestedVerificationCase": "nested_verification_case", + "nestedView": "nested_view", + "nestedViewpoint": "nested_viewpoint", + "owningDefinition": "owning_definition", + "owningUsage": "owning_usage", + "usage": "usage", + "variant": "variant", + "variantMembership": "variant_membership", + }) + definition: Many[Classifier] = Many("definition", "Classifier", ordered=True, derived=True) + "``Usage::definition`` (many, ordered, derived). Redefines ``Feature::type``." + directed_usage: Many[Usage] = Many("directedUsage", "Usage", ordered=True, derived=True) + "``Usage::directedUsage`` (many, ordered, derived)." + directedUsage = directed_usage + is_reference: Opt[bool] = Opt("isReference", "bool", derived=True) + "``Usage::isReference`` (single, derived)." + isReference = is_reference + is_variation: Opt[bool] = Opt("isVariation", "bool") + "``Usage::isVariation`` (single)." + isVariation = is_variation + may_time_vary: Opt[bool] = Opt("mayTimeVary", "bool", derived=True) + "``Usage::mayTimeVary`` (single, derived). Redefines ``Feature::isVariable``." + mayTimeVary = may_time_vary + nested_action: Many[ActionUsage] = Many("nestedAction", "ActionUsage", ordered=True, derived=True) + "``Usage::nestedAction`` (many, ordered, derived)." + nestedAction = nested_action + nested_allocation: Many[AllocationUsage] = Many("nestedAllocation", "AllocationUsage", ordered=True, derived=True) + "``Usage::nestedAllocation`` (many, ordered, derived)." + nestedAllocation = nested_allocation + nested_analysis_case: Many[AnalysisCaseUsage] = Many("nestedAnalysisCase", "AnalysisCaseUsage", ordered=True, derived=True) + "``Usage::nestedAnalysisCase`` (many, ordered, derived)." + nestedAnalysisCase = nested_analysis_case + nested_attribute: Many[AttributeUsage] = Many("nestedAttribute", "AttributeUsage", ordered=True, derived=True) + "``Usage::nestedAttribute`` (many, ordered, derived)." + nestedAttribute = nested_attribute + nested_calculation: Many[CalculationUsage] = Many("nestedCalculation", "CalculationUsage", ordered=True, derived=True) + "``Usage::nestedCalculation`` (many, ordered, derived)." + nestedCalculation = nested_calculation + nested_case: Many[CaseUsage] = Many("nestedCase", "CaseUsage", ordered=True, derived=True) + "``Usage::nestedCase`` (many, ordered, derived)." + nestedCase = nested_case + nested_concern: Many[ConcernUsage] = Many("nestedConcern", "ConcernUsage", ordered=False, derived=True) + "``Usage::nestedConcern`` (many, derived)." + nestedConcern = nested_concern + nested_connection: Many[ConnectorAsUsage] = Many("nestedConnection", "ConnectorAsUsage", ordered=True, derived=True) + "``Usage::nestedConnection`` (many, ordered, derived)." + nestedConnection = nested_connection + nested_constraint: Many[ConstraintUsage] = Many("nestedConstraint", "ConstraintUsage", ordered=True, derived=True) + "``Usage::nestedConstraint`` (many, ordered, derived)." + nestedConstraint = nested_constraint + nested_enumeration: Many[EnumerationUsage] = Many("nestedEnumeration", "EnumerationUsage", ordered=True, derived=True) + "``Usage::nestedEnumeration`` (many, ordered, derived)." + nestedEnumeration = nested_enumeration + nested_flow: Many[FlowUsage] = Many("nestedFlow", "FlowUsage", ordered=False, derived=True) + "``Usage::nestedFlow`` (many, derived)." + nestedFlow = nested_flow + nested_interface: Many[InterfaceUsage] = Many("nestedInterface", "InterfaceUsage", ordered=True, derived=True) + "``Usage::nestedInterface`` (many, ordered, derived)." + nestedInterface = nested_interface + nested_item: Many[ItemUsage] = Many("nestedItem", "ItemUsage", ordered=True, derived=True) + "``Usage::nestedItem`` (many, ordered, derived)." + nestedItem = nested_item + nested_metadata: Many[MetadataUsage] = Many("nestedMetadata", "MetadataUsage", ordered=True, derived=True) + "``Usage::nestedMetadata`` (many, ordered, derived)." + nestedMetadata = nested_metadata + nested_occurrence: Many[OccurrenceUsage] = Many("nestedOccurrence", "OccurrenceUsage", ordered=True, derived=True) + "``Usage::nestedOccurrence`` (many, ordered, derived)." + nestedOccurrence = nested_occurrence + nested_part: Many[PartUsage] = Many("nestedPart", "PartUsage", ordered=True, derived=True) + "``Usage::nestedPart`` (many, ordered, derived)." + nestedPart = nested_part + nested_port: Many[PortUsage] = Many("nestedPort", "PortUsage", ordered=True, derived=True) + "``Usage::nestedPort`` (many, ordered, derived)." + nestedPort = nested_port + nested_reference: Many[ReferenceUsage] = Many("nestedReference", "ReferenceUsage", ordered=True, derived=True) + "``Usage::nestedReference`` (many, ordered, derived)." + nestedReference = nested_reference + nested_rendering: Many[RenderingUsage] = Many("nestedRendering", "RenderingUsage", ordered=True, derived=True) + "``Usage::nestedRendering`` (many, ordered, derived)." + nestedRendering = nested_rendering + nested_requirement: Many[RequirementUsage] = Many("nestedRequirement", "RequirementUsage", ordered=True, derived=True) + "``Usage::nestedRequirement`` (many, ordered, derived)." + nestedRequirement = nested_requirement + nested_state: Many[StateUsage] = Many("nestedState", "StateUsage", ordered=True, derived=True) + "``Usage::nestedState`` (many, ordered, derived)." + nestedState = nested_state + nested_transition: Many[TransitionUsage] = Many("nestedTransition", "TransitionUsage", ordered=False, derived=True) + "``Usage::nestedTransition`` (many, derived)." + nestedTransition = nested_transition + nested_usage: Many[Usage] = Many("nestedUsage", "Usage", ordered=True, derived=True) + "``Usage::nestedUsage`` (many, ordered, derived)." + nestedUsage = nested_usage + nested_use_case: Many[UseCaseUsage] = Many("nestedUseCase", "UseCaseUsage", ordered=True, derived=True) + "``Usage::nestedUseCase`` (many, ordered, derived)." + nestedUseCase = nested_use_case + nested_verification_case: Many[VerificationCaseUsage] = Many("nestedVerificationCase", "VerificationCaseUsage", ordered=True, derived=True) + "``Usage::nestedVerificationCase`` (many, ordered, derived)." + nestedVerificationCase = nested_verification_case + nested_view: Many[ViewUsage] = Many("nestedView", "ViewUsage", ordered=True, derived=True) + "``Usage::nestedView`` (many, ordered, derived)." + nestedView = nested_view + nested_viewpoint: Many[ViewpointUsage] = Many("nestedViewpoint", "ViewpointUsage", ordered=True, derived=True) + "``Usage::nestedViewpoint`` (many, ordered, derived)." + nestedViewpoint = nested_viewpoint + owning_definition: Opt[Definition] = Opt("owningDefinition", "Definition", derived=True) + "``Usage::owningDefinition`` (single, derived)." + owningDefinition = owning_definition + owning_usage: Opt[Usage] = Opt("owningUsage", "Usage", derived=True) + "``Usage::owningUsage`` (single, derived)." + owningUsage = owning_usage + usage: Many[Usage] = Many("usage", "Usage", ordered=True, derived=True) + "``Usage::usage`` (many, ordered, derived)." + variant: Many[Usage] = Many("variant", "Usage", ordered=False, derived=True) + "``Usage::variant`` (many, derived)." + variant_membership: Many[VariantMembership] = Many("variantMembership", "VariantMembership", ordered=False, derived=True) + "``Usage::variantMembership`` (many, derived)." + variantMembership = variant_membership + + +class AttributeUsage(Usage): + "Metaclass ``AttributeUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "AttributeUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Usage.JSON_KEYS, + "attributeDefinition": "attribute_definition", + }) + attribute_definition: Many[DataType] = Many("attributeDefinition", "DataType", ordered=True, derived=True) + "``AttributeUsage::attributeDefinition`` (many, ordered, derived). Redefines ``Usage::definition``." + attributeDefinition = attribute_definition + + +class ConnectorAsUsage(Connector, Usage): + "Abstract metaclass ``ConnectorAsUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "ConnectorAsUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Usage.JSON_KEYS, + **Connector.JSON_KEYS, + }) + + +class BindingConnectorAsUsage(BindingConnector, ConnectorAsUsage): + "Metaclass ``BindingConnectorAsUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "BindingConnectorAsUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ConnectorAsUsage.JSON_KEYS, + **BindingConnector.JSON_KEYS, + }) + + +class EnumerationUsage(AttributeUsage): + "Metaclass ``EnumerationUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "EnumerationUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **AttributeUsage.JSON_KEYS, + "enumerationDefinition": "enumeration_definition", + }) + enumeration_definition: Opt[EnumerationDefinition] = Opt("enumerationDefinition", "EnumerationDefinition", derived=True) + "``EnumerationUsage::enumerationDefinition`` (single, derived). Redefines ``AttributeUsage::attributeDefinition``." + enumerationDefinition = enumeration_definition + + +class OccurrenceUsage(Usage): + "Metaclass ``OccurrenceUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "OccurrenceUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Usage.JSON_KEYS, + "individualDefinition": "individual_definition", + "isIndividual": "is_individual", + "occurrenceDefinition": "occurrence_definition", + "portionKind": "portion_kind", + }) + individual_definition: Opt[OccurrenceDefinition] = Opt("individualDefinition", "OccurrenceDefinition", derived=True) + "``OccurrenceUsage::individualDefinition`` (single, derived)." + individualDefinition = individual_definition + is_individual: Opt[bool] = Opt("isIndividual", "bool") + "``OccurrenceUsage::isIndividual`` (single)." + isIndividual = is_individual + occurrence_definition: Many[Class] = Many("occurrenceDefinition", "Class", ordered=True, derived=True) + "``OccurrenceUsage::occurrenceDefinition`` (many, ordered, derived). Redefines ``Usage::definition``." + occurrenceDefinition = occurrence_definition + portion_kind: Opt[PortionKind] = Opt("portionKind", "PortionKind") + "``OccurrenceUsage::portionKind`` (single)." + portionKind = portion_kind + + +class ActionUsage(OccurrenceUsage, Step): + "Metaclass ``ActionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "ActionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Step.JSON_KEYS, + **OccurrenceUsage.JSON_KEYS, + "actionDefinition": "action_definition", + }) + action_definition: Many[Behavior] = Many("actionDefinition", "Behavior", ordered=True, derived=True) + "``ActionUsage::actionDefinition`` (many, ordered, derived). Redefines ``Step::behavior``, ``OccurrenceUsage::occurrenceDefinition``." + actionDefinition = action_definition + + +class AcceptActionUsage(ActionUsage): + "Metaclass ``AcceptActionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "AcceptActionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ActionUsage.JSON_KEYS, + "payloadArgument": "payload_argument", + "payloadParameter": "payload_parameter", + "receiverArgument": "receiver_argument", + }) + payload_argument: Opt[Expression] = Opt("payloadArgument", "Expression", derived=True) + "``AcceptActionUsage::payloadArgument`` (single, derived)." + payloadArgument = payload_argument + payload_parameter: Opt[ReferenceUsage] = Opt("payloadParameter", "ReferenceUsage", derived=True) + "``AcceptActionUsage::payloadParameter`` (single, derived)." + payloadParameter = payload_parameter + receiver_argument: Opt[Expression] = Opt("receiverArgument", "Expression", derived=True) + "``AcceptActionUsage::receiverArgument`` (single, derived)." + receiverArgument = receiver_argument + + +class AssignmentActionUsage(ActionUsage): + "Metaclass ``AssignmentActionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "AssignmentActionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ActionUsage.JSON_KEYS, + "referent": "referent", + "targetArgument": "target_argument", + "valueExpression": "value_expression", + }) + referent: Opt[Feature] = Opt("referent", "Feature", derived=True) + "``AssignmentActionUsage::referent`` (single, derived)." + target_argument: Opt[Expression] = Opt("targetArgument", "Expression", derived=True) + "``AssignmentActionUsage::targetArgument`` (single, derived)." + targetArgument = target_argument + value_expression: Opt[Expression] = Opt("valueExpression", "Expression", derived=True) + "``AssignmentActionUsage::valueExpression`` (single, derived)." + valueExpression = value_expression + + +class CalculationUsage(ActionUsage, Expression): + "Metaclass ``CalculationUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "CalculationUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Expression.JSON_KEYS, + **ActionUsage.JSON_KEYS, + "calculationDefinition": "calculation_definition", + }) + calculation_definition: Opt[Function] = Opt("calculationDefinition", "Function", derived=True) + "``CalculationUsage::calculationDefinition`` (single, derived). Redefines ``Expression::function``, ``ActionUsage::actionDefinition``." + calculationDefinition = calculation_definition + + +class CaseUsage(CalculationUsage): + "Metaclass ``CaseUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "CaseUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **CalculationUsage.JSON_KEYS, + "actorParameter": "actor_parameter", + "caseDefinition": "case_definition", + "objectiveRequirement": "objective_requirement", + "subjectParameter": "subject_parameter", + }) + actor_parameter: Many[PartUsage] = Many("actorParameter", "PartUsage", ordered=True, derived=True) + "``CaseUsage::actorParameter`` (many, ordered, derived)." + actorParameter = actor_parameter + case_definition: Opt[CaseDefinition] = Opt("caseDefinition", "CaseDefinition", derived=True) + "``CaseUsage::caseDefinition`` (single, derived). Redefines ``CalculationUsage::calculationDefinition``." + caseDefinition = case_definition + objective_requirement: Opt[RequirementUsage] = Opt("objectiveRequirement", "RequirementUsage", derived=True) + "``CaseUsage::objectiveRequirement`` (single, derived)." + objectiveRequirement = objective_requirement + subject_parameter: Opt[Usage] = Opt("subjectParameter", "Usage", derived=True) + "``CaseUsage::subjectParameter`` (single, derived)." + subjectParameter = subject_parameter + + +class AnalysisCaseUsage(CaseUsage): + "Metaclass ``AnalysisCaseUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "AnalysisCaseUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **CaseUsage.JSON_KEYS, + "analysisCaseDefinition": "analysis_case_definition", + "resultExpression": "result_expression", + }) + analysis_case_definition: Opt[AnalysisCaseDefinition] = Opt("analysisCaseDefinition", "AnalysisCaseDefinition", derived=True) + "``AnalysisCaseUsage::analysisCaseDefinition`` (single, derived). Redefines ``CaseUsage::caseDefinition``." + analysisCaseDefinition = analysis_case_definition + result_expression: Opt[Expression] = Opt("resultExpression", "Expression", derived=True) + "``AnalysisCaseUsage::resultExpression`` (single, derived)." + resultExpression = result_expression + + +class ConstraintUsage(BooleanExpression, OccurrenceUsage): + "Metaclass ``ConstraintUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "ConstraintUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OccurrenceUsage.JSON_KEYS, + **BooleanExpression.JSON_KEYS, + "constraintDefinition": "constraint_definition", + }) + constraint_definition: Opt[Predicate] = Opt("constraintDefinition", "Predicate", derived=True) + "``ConstraintUsage::constraintDefinition`` (single, derived). Redefines ``BooleanExpression::predicate``." + constraintDefinition = constraint_definition + + +class AssertConstraintUsage(ConstraintUsage, Invariant): + "Metaclass ``AssertConstraintUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "AssertConstraintUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Invariant.JSON_KEYS, + **ConstraintUsage.JSON_KEYS, + "assertedConstraint": "asserted_constraint", + }) + asserted_constraint: Opt[ConstraintUsage] = Opt("assertedConstraint", "ConstraintUsage", derived=True) + "``AssertConstraintUsage::assertedConstraint`` (single, derived)." + assertedConstraint = asserted_constraint + + +class ControlNode(ActionUsage): + "Abstract metaclass ``ControlNode``." + __slots__ = () + METACLASS: ClassVar[str] = "ControlNode" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ActionUsage.JSON_KEYS, + }) + + +class DecisionNode(ControlNode): + "Metaclass ``DecisionNode``." + __slots__ = () + METACLASS: ClassVar[str] = "DecisionNode" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ControlNode.JSON_KEYS, + }) + + +class EventOccurrenceUsage(OccurrenceUsage): + "Metaclass ``EventOccurrenceUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "EventOccurrenceUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OccurrenceUsage.JSON_KEYS, + "eventOccurrence": "event_occurrence", + }) + event_occurrence: Opt[OccurrenceUsage] = Opt("eventOccurrence", "OccurrenceUsage", derived=True) + "``EventOccurrenceUsage::eventOccurrence`` (single, derived)." + eventOccurrence = event_occurrence + + +class FlowUsage(ActionUsage, ConnectorAsUsage, Flow): + "Metaclass ``FlowUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "FlowUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Flow.JSON_KEYS, + **ConnectorAsUsage.JSON_KEYS, + **ActionUsage.JSON_KEYS, + "flowDefinition": "flow_definition", + }) + flow_definition: Many[Interaction] = Many("flowDefinition", "Interaction", ordered=True, derived=True) + "``FlowUsage::flowDefinition`` (many, ordered, derived). Redefines ``ActionUsage::actionDefinition``, ``Flow::interaction``." + flowDefinition = flow_definition + + +class ForkNode(ControlNode): + "Metaclass ``ForkNode``." + __slots__ = () + METACLASS: ClassVar[str] = "ForkNode" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ControlNode.JSON_KEYS, + }) + + +class IfActionUsage(ActionUsage): + "Metaclass ``IfActionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "IfActionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ActionUsage.JSON_KEYS, + "elseAction": "else_action", + "ifArgument": "if_argument", + "thenAction": "then_action", + }) + else_action: Opt[ActionUsage] = Opt("elseAction", "ActionUsage", derived=True) + "``IfActionUsage::elseAction`` (single, derived)." + elseAction = else_action + if_argument: Opt[Expression] = Opt("ifArgument", "Expression", derived=True) + "``IfActionUsage::ifArgument`` (single, derived)." + ifArgument = if_argument + then_action: Opt[ActionUsage] = Opt("thenAction", "ActionUsage", derived=True) + "``IfActionUsage::thenAction`` (single, derived)." + thenAction = then_action + + +class ItemUsage(OccurrenceUsage): + "Metaclass ``ItemUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "ItemUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OccurrenceUsage.JSON_KEYS, + "itemDefinition": "item_definition", + }) + item_definition: Many[Structure] = Many("itemDefinition", "Structure", ordered=True, derived=True) + "``ItemUsage::itemDefinition`` (many, ordered, derived)." + itemDefinition = item_definition + + +class JoinNode(ControlNode): + "Metaclass ``JoinNode``." + __slots__ = () + METACLASS: ClassVar[str] = "JoinNode" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ControlNode.JSON_KEYS, + }) + + +class LoopActionUsage(ActionUsage): + "Abstract metaclass ``LoopActionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "LoopActionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ActionUsage.JSON_KEYS, + "bodyAction": "body_action", + }) + body_action: Opt[ActionUsage] = Opt("bodyAction", "ActionUsage", derived=True) + "``LoopActionUsage::bodyAction`` (single, derived)." + bodyAction = body_action + + +class ForLoopActionUsage(LoopActionUsage): + "Metaclass ``ForLoopActionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "ForLoopActionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **LoopActionUsage.JSON_KEYS, + "loopVariable": "loop_variable", + "seqArgument": "seq_argument", + }) + loop_variable: Opt[ReferenceUsage] = Opt("loopVariable", "ReferenceUsage", derived=True) + "``ForLoopActionUsage::loopVariable`` (single, derived)." + loopVariable = loop_variable + seq_argument: Opt[Expression] = Opt("seqArgument", "Expression", derived=True) + "``ForLoopActionUsage::seqArgument`` (single, derived)." + seqArgument = seq_argument + + +class MergeNode(ControlNode): + "Metaclass ``MergeNode``." + __slots__ = () + METACLASS: ClassVar[str] = "MergeNode" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ControlNode.JSON_KEYS, + }) + + +class MetadataUsage(ItemUsage, MetadataFeature): + "Metaclass ``MetadataUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "MetadataUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **MetadataFeature.JSON_KEYS, + **ItemUsage.JSON_KEYS, + "metadataDefinition": "metadata_definition", + }) + metadata_definition: Opt[Metaclass] = Opt("metadataDefinition", "Metaclass", derived=True) + "``MetadataUsage::metadataDefinition`` (single, derived). Redefines ``ItemUsage::itemDefinition``, ``MetadataFeature::metaclass``." + metadataDefinition = metadata_definition + + +class PartUsage(ItemUsage): + "Metaclass ``PartUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "PartUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ItemUsage.JSON_KEYS, + "partDefinition": "part_definition", + }) + part_definition: Many[PartDefinition] = Many("partDefinition", "PartDefinition", ordered=True, derived=True) + "``PartUsage::partDefinition`` (many, ordered, derived)." + partDefinition = part_definition + + +class ConnectionUsage(ConnectorAsUsage, PartUsage): + "Metaclass ``ConnectionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "ConnectionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **PartUsage.JSON_KEYS, + **ConnectorAsUsage.JSON_KEYS, + "connectionDefinition": "connection_definition", + }) + connection_definition: Many[AssociationStructure] = Many("connectionDefinition", "AssociationStructure", ordered=True, derived=True) + "``ConnectionUsage::connectionDefinition`` (many, ordered, derived). Redefines ``Connector::association``." + connectionDefinition = connection_definition + + +class AllocationUsage(ConnectionUsage): + "Metaclass ``AllocationUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "AllocationUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ConnectionUsage.JSON_KEYS, + "allocationDefinition": "allocation_definition", + }) + allocation_definition: Many[AllocationDefinition] = Many("allocationDefinition", "AllocationDefinition", ordered=True, derived=True) + "``AllocationUsage::allocationDefinition`` (many, ordered, derived). Redefines ``ConnectionUsage::connectionDefinition``." + allocationDefinition = allocation_definition + + +class InterfaceUsage(ConnectionUsage): + "Metaclass ``InterfaceUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "InterfaceUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ConnectionUsage.JSON_KEYS, + "interfaceDefinition": "interface_definition", + }) + interface_definition: Many[InterfaceDefinition] = Many("interfaceDefinition", "InterfaceDefinition", ordered=False, derived=True) + "``InterfaceUsage::interfaceDefinition`` (many, derived). Redefines ``ConnectionUsage::connectionDefinition``." + interfaceDefinition = interface_definition + + +class PerformActionUsage(ActionUsage, EventOccurrenceUsage): + "Metaclass ``PerformActionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "PerformActionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **EventOccurrenceUsage.JSON_KEYS, + **ActionUsage.JSON_KEYS, + "performedAction": "performed_action", + }) + performed_action: Opt[ActionUsage] = Opt("performedAction", "ActionUsage", derived=True) + "``PerformActionUsage::performedAction`` (single, derived). Redefines ``EventOccurrenceUsage::eventOccurrence``." + performedAction = performed_action + + +class PortUsage(OccurrenceUsage): + "Metaclass ``PortUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "PortUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OccurrenceUsage.JSON_KEYS, + "portDefinition": "port_definition", + }) + port_definition: Many[PortDefinition] = Many("portDefinition", "PortDefinition", ordered=True, derived=True) + "``PortUsage::portDefinition`` (many, ordered, derived). Redefines ``OccurrenceUsage::occurrenceDefinition``." + portDefinition = port_definition + + +class ReferenceUsage(Usage): + "Metaclass ``ReferenceUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "ReferenceUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Usage.JSON_KEYS, + }) + + +class RenderingUsage(PartUsage): + "Metaclass ``RenderingUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "RenderingUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **PartUsage.JSON_KEYS, + "renderingDefinition": "rendering_definition", + }) + rendering_definition: Opt[RenderingDefinition] = Opt("renderingDefinition", "RenderingDefinition", derived=True) + "``RenderingUsage::renderingDefinition`` (single, derived). Redefines ``PartUsage::partDefinition``." + renderingDefinition = rendering_definition + + +class RequirementUsage(ConstraintUsage): + "Metaclass ``RequirementUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "RequirementUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ConstraintUsage.JSON_KEYS, + "actorParameter": "actor_parameter", + "assumedConstraint": "assumed_constraint", + "framedConcern": "framed_concern", + "reqId": "req_id", + "requiredConstraint": "required_constraint", + "requirementDefinition": "requirement_definition", + "stakeholderParameter": "stakeholder_parameter", + "subjectParameter": "subject_parameter", + "text": "text", + }) + actor_parameter: Many[PartUsage] = Many("actorParameter", "PartUsage", ordered=True, derived=True) + "``RequirementUsage::actorParameter`` (many, ordered, derived)." + actorParameter = actor_parameter + assumed_constraint: Many[ConstraintUsage] = Many("assumedConstraint", "ConstraintUsage", ordered=True, derived=True) + "``RequirementUsage::assumedConstraint`` (many, ordered, derived)." + assumedConstraint = assumed_constraint + framed_concern: Many[ConcernUsage] = Many("framedConcern", "ConcernUsage", ordered=True, derived=True) + "``RequirementUsage::framedConcern`` (many, ordered, derived)." + framedConcern = framed_concern + req_id: Opt[str] = Opt("reqId", "str") + "``RequirementUsage::reqId`` (single). Redefines ``Element::declaredShortName``." + reqId = req_id + required_constraint: Many[ConstraintUsage] = Many("requiredConstraint", "ConstraintUsage", ordered=True, derived=True) + "``RequirementUsage::requiredConstraint`` (many, ordered, derived)." + requiredConstraint = required_constraint + requirement_definition: Opt[RequirementDefinition] = Opt("requirementDefinition", "RequirementDefinition", derived=True) + "``RequirementUsage::requirementDefinition`` (single, derived). Redefines ``ConstraintUsage::constraintDefinition``." + requirementDefinition = requirement_definition + stakeholder_parameter: Many[PartUsage] = Many("stakeholderParameter", "PartUsage", ordered=True, derived=True) + "``RequirementUsage::stakeholderParameter`` (many, ordered, derived)." + stakeholderParameter = stakeholder_parameter + subject_parameter: Opt[Usage] = Opt("subjectParameter", "Usage", derived=True) + "``RequirementUsage::subjectParameter`` (single, derived)." + subjectParameter = subject_parameter + text: Many[str] = Many("text", "str", ordered=False, derived=True) + "``RequirementUsage::text`` (many, derived)." + + +class ConcernUsage(RequirementUsage): + "Metaclass ``ConcernUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "ConcernUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **RequirementUsage.JSON_KEYS, + "concernDefinition": "concern_definition", + }) + concern_definition: Opt[ConcernDefinition] = Opt("concernDefinition", "ConcernDefinition", derived=True) + "``ConcernUsage::concernDefinition`` (single, derived). Redefines ``RequirementUsage::requirementDefinition``." + concernDefinition = concern_definition + + +class SatisfyRequirementUsage(AssertConstraintUsage, RequirementUsage): + "Metaclass ``SatisfyRequirementUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "SatisfyRequirementUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **RequirementUsage.JSON_KEYS, + **AssertConstraintUsage.JSON_KEYS, + "satisfiedRequirement": "satisfied_requirement", + "satisfyingFeature": "satisfying_feature", + }) + satisfied_requirement: Opt[RequirementUsage] = Opt("satisfiedRequirement", "RequirementUsage", derived=True) + "``SatisfyRequirementUsage::satisfiedRequirement`` (single, derived). Redefines ``AssertConstraintUsage::assertedConstraint``." + satisfiedRequirement = satisfied_requirement + satisfying_feature: Opt[Feature] = Opt("satisfyingFeature", "Feature", derived=True) + "``SatisfyRequirementUsage::satisfyingFeature`` (single, derived)." + satisfyingFeature = satisfying_feature + + +class SendActionUsage(ActionUsage): + "Metaclass ``SendActionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "SendActionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ActionUsage.JSON_KEYS, + "payloadArgument": "payload_argument", + "receiverArgument": "receiver_argument", + "senderArgument": "sender_argument", + }) + payload_argument: Opt[Expression] = Opt("payloadArgument", "Expression", derived=True) + "``SendActionUsage::payloadArgument`` (single, derived)." + payloadArgument = payload_argument + receiver_argument: Opt[Expression] = Opt("receiverArgument", "Expression", derived=True) + "``SendActionUsage::receiverArgument`` (single, derived)." + receiverArgument = receiver_argument + sender_argument: Opt[Expression] = Opt("senderArgument", "Expression", derived=True) + "``SendActionUsage::senderArgument`` (single, derived)." + senderArgument = sender_argument + + +class StateUsage(ActionUsage): + "Metaclass ``StateUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "StateUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ActionUsage.JSON_KEYS, + "doAction": "do_action", + "entryAction": "entry_action", + "exitAction": "exit_action", + "isParallel": "is_parallel", + "stateDefinition": "state_definition", + }) + do_action: Opt[ActionUsage] = Opt("doAction", "ActionUsage", derived=True) + "``StateUsage::doAction`` (single, derived)." + doAction = do_action + entry_action: Opt[ActionUsage] = Opt("entryAction", "ActionUsage", derived=True) + "``StateUsage::entryAction`` (single, derived)." + entryAction = entry_action + exit_action: Opt[ActionUsage] = Opt("exitAction", "ActionUsage", derived=True) + "``StateUsage::exitAction`` (single, derived)." + exitAction = exit_action + is_parallel: Opt[bool] = Opt("isParallel", "bool") + "``StateUsage::isParallel`` (single)." + isParallel = is_parallel + state_definition: Many[Behavior] = Many("stateDefinition", "Behavior", ordered=True, derived=True) + "``StateUsage::stateDefinition`` (many, ordered, derived). Redefines ``ActionUsage::actionDefinition``." + stateDefinition = state_definition + + +class ExhibitStateUsage(PerformActionUsage, StateUsage): + "Metaclass ``ExhibitStateUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "ExhibitStateUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **StateUsage.JSON_KEYS, + **PerformActionUsage.JSON_KEYS, + "exhibitedState": "exhibited_state", + }) + exhibited_state: Opt[StateUsage] = Opt("exhibitedState", "StateUsage", derived=True) + "``ExhibitStateUsage::exhibitedState`` (single, derived). Redefines ``PerformActionUsage::performedAction``." + exhibitedState = exhibited_state + + +class SuccessionAsUsage(ConnectorAsUsage, Succession): + "Metaclass ``SuccessionAsUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "SuccessionAsUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **Succession.JSON_KEYS, + **ConnectorAsUsage.JSON_KEYS, + }) + + +class SuccessionFlowUsage(FlowUsage, SuccessionFlow): + "Metaclass ``SuccessionFlowUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "SuccessionFlowUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **SuccessionFlow.JSON_KEYS, + **FlowUsage.JSON_KEYS, + }) + + +class TerminateActionUsage(ActionUsage): + "Metaclass ``TerminateActionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "TerminateActionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ActionUsage.JSON_KEYS, + "terminatedOccurrenceArgument": "terminated_occurrence_argument", + }) + terminated_occurrence_argument: Opt[Expression] = Opt("terminatedOccurrenceArgument", "Expression", derived=True) + "``TerminateActionUsage::terminatedOccurrenceArgument`` (single, derived)." + terminatedOccurrenceArgument = terminated_occurrence_argument + + +class TransitionUsage(ActionUsage): + "Metaclass ``TransitionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "TransitionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **ActionUsage.JSON_KEYS, + "effectAction": "effect_action", + "guardExpression": "guard_expression", + "source": "source", + "succession": "succession", + "target": "target", + "triggerAction": "trigger_action", + }) + effect_action: Many[ActionUsage] = Many("effectAction", "ActionUsage", ordered=False, derived=True) + "``TransitionUsage::effectAction`` (many, derived)." + effectAction = effect_action + guard_expression: Many[Expression] = Many("guardExpression", "Expression", ordered=False, derived=True) + "``TransitionUsage::guardExpression`` (many, derived)." + guardExpression = guard_expression + source: Opt[ActionUsage] = Opt("source", "ActionUsage", derived=True) + "``TransitionUsage::source`` (single, derived)." + succession: Opt[Succession] = Opt("succession", "Succession", derived=True) + "``TransitionUsage::succession`` (single, derived)." + target: Opt[ActionUsage] = Opt("target", "ActionUsage", derived=True) + "``TransitionUsage::target`` (single, derived)." + trigger_action: Many[AcceptActionUsage] = Many("triggerAction", "AcceptActionUsage", ordered=False, derived=True) + "``TransitionUsage::triggerAction`` (many, derived)." + triggerAction = trigger_action + + +class UseCaseDefinition(CaseDefinition): + "Metaclass ``UseCaseDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "UseCaseDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **CaseDefinition.JSON_KEYS, + "includedUseCase": "included_use_case", + }) + included_use_case: Many[UseCaseUsage] = Many("includedUseCase", "UseCaseUsage", ordered=True, derived=True) + "``UseCaseDefinition::includedUseCase`` (many, ordered, derived)." + includedUseCase = included_use_case + + +class UseCaseUsage(CaseUsage): + "Metaclass ``UseCaseUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "UseCaseUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **CaseUsage.JSON_KEYS, + "includedUseCase": "included_use_case", + "useCaseDefinition": "use_case_definition", + }) + included_use_case: Many[UseCaseUsage] = Many("includedUseCase", "UseCaseUsage", ordered=True, derived=True) + "``UseCaseUsage::includedUseCase`` (many, ordered, derived)." + includedUseCase = included_use_case + use_case_definition: Opt[UseCaseDefinition] = Opt("useCaseDefinition", "UseCaseDefinition", derived=True) + "``UseCaseUsage::useCaseDefinition`` (single, derived). Redefines ``CaseUsage::caseDefinition``." + useCaseDefinition = use_case_definition + + +class IncludeUseCaseUsage(PerformActionUsage, UseCaseUsage): + "Metaclass ``IncludeUseCaseUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "IncludeUseCaseUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **UseCaseUsage.JSON_KEYS, + **PerformActionUsage.JSON_KEYS, + "useCaseIncluded": "use_case_included", + }) + use_case_included: Opt[UseCaseUsage] = Opt("useCaseIncluded", "UseCaseUsage", derived=True) + "``IncludeUseCaseUsage::useCaseIncluded`` (single, derived). Redefines ``PerformActionUsage::performedAction``." + useCaseIncluded = use_case_included + + +class VariantMembership(OwningMembership): + "Metaclass ``VariantMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "VariantMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **OwningMembership.JSON_KEYS, + "ownedVariantUsage": "owned_variant_usage", + }) + owned_variant_usage: Opt[Usage] = Opt("ownedVariantUsage", "Usage", derived=True) + "``VariantMembership::ownedVariantUsage`` (single, derived). Redefines ``OwningMembership::ownedMemberElement``." + ownedVariantUsage = owned_variant_usage + + +class VerificationCaseDefinition(CaseDefinition): + "Metaclass ``VerificationCaseDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "VerificationCaseDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **CaseDefinition.JSON_KEYS, + "verifiedRequirement": "verified_requirement", + }) + verified_requirement: Many[RequirementUsage] = Many("verifiedRequirement", "RequirementUsage", ordered=True, derived=True) + "``VerificationCaseDefinition::verifiedRequirement`` (many, ordered, derived)." + verifiedRequirement = verified_requirement + + +class VerificationCaseUsage(CaseUsage): + "Metaclass ``VerificationCaseUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "VerificationCaseUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **CaseUsage.JSON_KEYS, + "verificationCaseDefinition": "verification_case_definition", + "verifiedRequirement": "verified_requirement", + }) + verification_case_definition: Opt[VerificationCaseDefinition] = Opt("verificationCaseDefinition", "VerificationCaseDefinition", derived=True) + "``VerificationCaseUsage::verificationCaseDefinition`` (single, derived)." + verificationCaseDefinition = verification_case_definition + verified_requirement: Many[RequirementUsage] = Many("verifiedRequirement", "RequirementUsage", ordered=True, derived=True) + "``VerificationCaseUsage::verifiedRequirement`` (many, ordered, derived)." + verifiedRequirement = verified_requirement + + +class ViewDefinition(PartDefinition): + "Metaclass ``ViewDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "ViewDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **PartDefinition.JSON_KEYS, + "satisfiedViewpoint": "satisfied_viewpoint", + "view": "view", + "viewCondition": "view_condition", + "viewRendering": "view_rendering", + }) + satisfied_viewpoint: Many[ViewpointUsage] = Many("satisfiedViewpoint", "ViewpointUsage", ordered=True, derived=True) + "``ViewDefinition::satisfiedViewpoint`` (many, ordered, derived)." + satisfiedViewpoint = satisfied_viewpoint + view: Many[ViewUsage] = Many("view", "ViewUsage", ordered=True, derived=True) + "``ViewDefinition::view`` (many, ordered, derived)." + view_condition: Many[Expression] = Many("viewCondition", "Expression", ordered=True, derived=True) + "``ViewDefinition::viewCondition`` (many, ordered, derived)." + viewCondition = view_condition + view_rendering: Opt[RenderingUsage] = Opt("viewRendering", "RenderingUsage", derived=True) + "``ViewDefinition::viewRendering`` (single, derived)." + viewRendering = view_rendering + + +class ViewRenderingMembership(FeatureMembership): + "Metaclass ``ViewRenderingMembership``." + __slots__ = () + METACLASS: ClassVar[str] = "ViewRenderingMembership" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **FeatureMembership.JSON_KEYS, + "ownedRendering": "owned_rendering", + "referencedRendering": "referenced_rendering", + }) + owned_rendering: Opt[RenderingUsage] = Opt("ownedRendering", "RenderingUsage", derived=True) + "``ViewRenderingMembership::ownedRendering`` (single, derived). Redefines ``FeatureMembership::ownedMemberFeature``." + ownedRendering = owned_rendering + referenced_rendering: Opt[RenderingUsage] = Opt("referencedRendering", "RenderingUsage", derived=True) + "``ViewRenderingMembership::referencedRendering`` (single, derived)." + referencedRendering = referenced_rendering + + +class ViewUsage(PartUsage): + "Metaclass ``ViewUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "ViewUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **PartUsage.JSON_KEYS, + "exposedElement": "exposed_element", + "satisfiedViewpoint": "satisfied_viewpoint", + "viewCondition": "view_condition", + "viewDefinition": "view_definition", + "viewRendering": "view_rendering", + }) + exposed_element: Many[Element] = Many("exposedElement", "Element", ordered=True, derived=True) + "``ViewUsage::exposedElement`` (many, ordered, derived)." + exposedElement = exposed_element + satisfied_viewpoint: Many[ViewpointUsage] = Many("satisfiedViewpoint", "ViewpointUsage", ordered=True, derived=True) + "``ViewUsage::satisfiedViewpoint`` (many, ordered, derived)." + satisfiedViewpoint = satisfied_viewpoint + view_condition: Many[Expression] = Many("viewCondition", "Expression", ordered=True, derived=True) + "``ViewUsage::viewCondition`` (many, ordered, derived)." + viewCondition = view_condition + view_definition: Opt[ViewDefinition] = Opt("viewDefinition", "ViewDefinition", derived=True) + "``ViewUsage::viewDefinition`` (single, derived). Redefines ``PartUsage::partDefinition``." + viewDefinition = view_definition + view_rendering: Opt[RenderingUsage] = Opt("viewRendering", "RenderingUsage", derived=True) + "``ViewUsage::viewRendering`` (single, derived)." + viewRendering = view_rendering + + +class ViewpointDefinition(RequirementDefinition): + "Metaclass ``ViewpointDefinition``." + __slots__ = () + METACLASS: ClassVar[str] = "ViewpointDefinition" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **RequirementDefinition.JSON_KEYS, + "viewpointStakeholder": "viewpoint_stakeholder", + }) + viewpoint_stakeholder: Many[PartUsage] = Many("viewpointStakeholder", "PartUsage", ordered=True, derived=True) + "``ViewpointDefinition::viewpointStakeholder`` (many, ordered, derived)." + viewpointStakeholder = viewpoint_stakeholder + + +class ViewpointUsage(RequirementUsage): + "Metaclass ``ViewpointUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "ViewpointUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **RequirementUsage.JSON_KEYS, + "viewpointDefinition": "viewpoint_definition", + "viewpointStakeholder": "viewpoint_stakeholder", + }) + viewpoint_definition: Opt[ViewpointDefinition] = Opt("viewpointDefinition", "ViewpointDefinition", derived=True) + "``ViewpointUsage::viewpointDefinition`` (single, derived). Redefines ``RequirementUsage::requirementDefinition``." + viewpointDefinition = viewpoint_definition + viewpoint_stakeholder: Many[PartUsage] = Many("viewpointStakeholder", "PartUsage", ordered=True, derived=True) + "``ViewpointUsage::viewpointStakeholder`` (many, ordered, derived)." + viewpointStakeholder = viewpoint_stakeholder + + +class WhileLoopActionUsage(LoopActionUsage): + "Metaclass ``WhileLoopActionUsage``." + __slots__ = () + METACLASS: ClassVar[str] = "WhileLoopActionUsage" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({ + **LoopActionUsage.JSON_KEYS, + "untilArgument": "until_argument", + "whileArgument": "while_argument", + }) + until_argument: Opt[Expression] = Opt("untilArgument", "Expression", derived=True) + "``WhileLoopActionUsage::untilArgument`` (single, derived)." + untilArgument = until_argument + while_argument: Opt[Expression] = Opt("whileArgument", "Expression", derived=True) + "``WhileLoopActionUsage::whileArgument`` (single, derived)." + whileArgument = while_argument + + +REGISTRY: Mapping[str, builtins.type[Element]] = MappingProxyType({ + "Element": Element, + "AnnotatingElement": AnnotatingElement, + "Comment": Comment, + "Documentation": Documentation, + "Namespace": Namespace, + "Package": Package, + "LibraryPackage": LibraryPackage, + "Relationship": Relationship, + "Annotation": Annotation, + "Conjugation": Conjugation, + "Dependency": Dependency, + "Differencing": Differencing, + "Disjoining": Disjoining, + "FeatureChaining": FeatureChaining, + "FeatureInverting": FeatureInverting, + "Import": Import, + "Expose": Expose, + "Intersecting": Intersecting, + "Membership": Membership, + "MembershipImport": MembershipImport, + "MembershipExpose": MembershipExpose, + "NamespaceImport": NamespaceImport, + "NamespaceExpose": NamespaceExpose, + "OwningMembership": OwningMembership, + "ElementFilterMembership": ElementFilterMembership, + "FeatureMembership": FeatureMembership, + "EndFeatureMembership": EndFeatureMembership, + "FeatureValue": FeatureValue, + "ObjectiveMembership": ObjectiveMembership, + "ParameterMembership": ParameterMembership, + "ActorMembership": ActorMembership, + "PortConjugation": PortConjugation, + "RequirementConstraintMembership": RequirementConstraintMembership, + "FramedConcernMembership": FramedConcernMembership, + "RequirementVerificationMembership": RequirementVerificationMembership, + "ResultExpressionMembership": ResultExpressionMembership, + "ReturnParameterMembership": ReturnParameterMembership, + "Specialization": Specialization, + "FeatureTyping": FeatureTyping, + "ConjugatedPortTyping": ConjugatedPortTyping, + "StakeholderMembership": StakeholderMembership, + "StateSubactionMembership": StateSubactionMembership, + "Subclassification": Subclassification, + "SubjectMembership": SubjectMembership, + "Subsetting": Subsetting, + "CrossSubsetting": CrossSubsetting, + "Redefinition": Redefinition, + "ReferenceSubsetting": ReferenceSubsetting, + "TextualRepresentation": TextualRepresentation, + "TransitionFeatureMembership": TransitionFeatureMembership, + "Type": Type, + "Classifier": Classifier, + "Association": Association, + "Class": Class, + "Behavior": Behavior, + "DataType": DataType, + "Definition": Definition, + "AttributeDefinition": AttributeDefinition, + "EnumerationDefinition": EnumerationDefinition, + "Feature": Feature, + "Connector": Connector, + "BindingConnector": BindingConnector, + "FlowEnd": FlowEnd, + "Function": Function, + "Interaction": Interaction, + "MetadataFeature": MetadataFeature, + "Multiplicity": Multiplicity, + "MultiplicityRange": MultiplicityRange, + "OccurrenceDefinition": OccurrenceDefinition, + "ActionDefinition": ActionDefinition, + "CalculationDefinition": CalculationDefinition, + "CaseDefinition": CaseDefinition, + "AnalysisCaseDefinition": AnalysisCaseDefinition, + "FlowDefinition": FlowDefinition, + "PayloadFeature": PayloadFeature, + "Predicate": Predicate, + "ConstraintDefinition": ConstraintDefinition, + "RequirementDefinition": RequirementDefinition, + "ConcernDefinition": ConcernDefinition, + "StateDefinition": StateDefinition, + "Step": Step, + "Expression": Expression, + "BooleanExpression": BooleanExpression, + "FeatureReferenceExpression": FeatureReferenceExpression, + "Flow": Flow, + "InstantiationExpression": InstantiationExpression, + "ConstructorExpression": ConstructorExpression, + "Invariant": Invariant, + "InvocationExpression": InvocationExpression, + "LiteralExpression": LiteralExpression, + "LiteralBoolean": LiteralBoolean, + "LiteralInfinity": LiteralInfinity, + "LiteralInteger": LiteralInteger, + "LiteralRational": LiteralRational, + "LiteralString": LiteralString, + "MetadataAccessExpression": MetadataAccessExpression, + "NullExpression": NullExpression, + "OperatorExpression": OperatorExpression, + "CollectExpression": CollectExpression, + "FeatureChainExpression": FeatureChainExpression, + "IndexExpression": IndexExpression, + "SelectExpression": SelectExpression, + "Structure": Structure, + "AssociationStructure": AssociationStructure, + "ItemDefinition": ItemDefinition, + "Metaclass": Metaclass, + "MetadataDefinition": MetadataDefinition, + "PartDefinition": PartDefinition, + "ConnectionDefinition": ConnectionDefinition, + "AllocationDefinition": AllocationDefinition, + "InterfaceDefinition": InterfaceDefinition, + "PortDefinition": PortDefinition, + "ConjugatedPortDefinition": ConjugatedPortDefinition, + "RenderingDefinition": RenderingDefinition, + "Succession": Succession, + "SuccessionFlow": SuccessionFlow, + "TriggerInvocationExpression": TriggerInvocationExpression, + "TypeFeaturing": TypeFeaturing, + "Unioning": Unioning, + "Usage": Usage, + "AttributeUsage": AttributeUsage, + "ConnectorAsUsage": ConnectorAsUsage, + "BindingConnectorAsUsage": BindingConnectorAsUsage, + "EnumerationUsage": EnumerationUsage, + "OccurrenceUsage": OccurrenceUsage, + "ActionUsage": ActionUsage, + "AcceptActionUsage": AcceptActionUsage, + "AssignmentActionUsage": AssignmentActionUsage, + "CalculationUsage": CalculationUsage, + "CaseUsage": CaseUsage, + "AnalysisCaseUsage": AnalysisCaseUsage, + "ConstraintUsage": ConstraintUsage, + "AssertConstraintUsage": AssertConstraintUsage, + "ControlNode": ControlNode, + "DecisionNode": DecisionNode, + "EventOccurrenceUsage": EventOccurrenceUsage, + "FlowUsage": FlowUsage, + "ForkNode": ForkNode, + "IfActionUsage": IfActionUsage, + "ItemUsage": ItemUsage, + "JoinNode": JoinNode, + "LoopActionUsage": LoopActionUsage, + "ForLoopActionUsage": ForLoopActionUsage, + "MergeNode": MergeNode, + "MetadataUsage": MetadataUsage, + "PartUsage": PartUsage, + "ConnectionUsage": ConnectionUsage, + "AllocationUsage": AllocationUsage, + "InterfaceUsage": InterfaceUsage, + "PerformActionUsage": PerformActionUsage, + "PortUsage": PortUsage, + "ReferenceUsage": ReferenceUsage, + "RenderingUsage": RenderingUsage, + "RequirementUsage": RequirementUsage, + "ConcernUsage": ConcernUsage, + "SatisfyRequirementUsage": SatisfyRequirementUsage, + "SendActionUsage": SendActionUsage, + "StateUsage": StateUsage, + "ExhibitStateUsage": ExhibitStateUsage, + "SuccessionAsUsage": SuccessionAsUsage, + "SuccessionFlowUsage": SuccessionFlowUsage, + "TerminateActionUsage": TerminateActionUsage, + "TransitionUsage": TransitionUsage, + "UseCaseDefinition": UseCaseDefinition, + "UseCaseUsage": UseCaseUsage, + "IncludeUseCaseUsage": IncludeUseCaseUsage, + "VariantMembership": VariantMembership, + "VerificationCaseDefinition": VerificationCaseDefinition, + "VerificationCaseUsage": VerificationCaseUsage, + "ViewDefinition": ViewDefinition, + "ViewRenderingMembership": ViewRenderingMembership, + "ViewUsage": ViewUsage, + "ViewpointDefinition": ViewpointDefinition, + "ViewpointUsage": ViewpointUsage, + "WhileLoopActionUsage": WhileLoopActionUsage, +}) + +ENUMERATIONS: Mapping[str, builtins.type[Enum]] = MappingProxyType({ + "FeatureDirectionKind": FeatureDirectionKind, + "PortionKind": PortionKind, + "RequirementConstraintKind": RequirementConstraintKind, + "StateSubactionKind": StateSubactionKind, + "TransitionFeatureKind": TransitionFeatureKind, + "TriggerKind": TriggerKind, + "VisibilityKind": VisibilityKind, +}) + +RUNTIME_MEMBERS = frozenset({ + "METACLASS", + "JSON_KEYS", + "from_json_key", + "json_key", + "json_id", + "json_type", + "json_value", + "graph", + "metaclass_name", +}) + +__all__ = [ + "AcceptActionUsage", + "ActionDefinition", + "ActionUsage", + "ActorMembership", + "AllocationDefinition", + "AllocationUsage", + "AnalysisCaseDefinition", + "AnalysisCaseUsage", + "AnnotatingElement", + "Annotation", + "AssertConstraintUsage", + "AssignmentActionUsage", + "Association", + "AssociationStructure", + "AttributeDefinition", + "AttributeUsage", + "Behavior", + "BindingConnector", + "BindingConnectorAsUsage", + "BooleanExpression", + "CalculationDefinition", + "CalculationUsage", + "CaseDefinition", + "CaseUsage", + "Class", + "Classifier", + "CollectExpression", + "Comment", + "ConcernDefinition", + "ConcernUsage", + "ConjugatedPortDefinition", + "ConjugatedPortTyping", + "Conjugation", + "ConnectionDefinition", + "ConnectionUsage", + "Connector", + "ConnectorAsUsage", + "ConstraintDefinition", + "ConstraintUsage", + "ConstructorExpression", + "ControlNode", + "CrossSubsetting", + "DataType", + "DecisionNode", + "Definition", + "Dependency", + "Differencing", + "Disjoining", + "Documentation", + "ENUMERATIONS", + "Element", + "ElementFilterMembership", + "EndFeatureMembership", + "EnumerationDefinition", + "EnumerationUsage", + "EventOccurrenceUsage", + "ExhibitStateUsage", + "Expose", + "Expression", + "Feature", + "FeatureChainExpression", + "FeatureChaining", + "FeatureDirectionKind", + "FeatureInverting", + "FeatureMembership", + "FeatureReferenceExpression", + "FeatureTyping", + "FeatureValue", + "Flow", + "FlowDefinition", + "FlowEnd", + "FlowUsage", + "ForLoopActionUsage", + "ForkNode", + "FramedConcernMembership", + "Function", + "IfActionUsage", + "Import", + "IncludeUseCaseUsage", + "IndexExpression", + "InstantiationExpression", + "Interaction", + "InterfaceDefinition", + "InterfaceUsage", + "Intersecting", + "Invariant", + "InvocationExpression", + "ItemDefinition", + "ItemUsage", + "JoinNode", + "LibraryPackage", + "LiteralBoolean", + "LiteralExpression", + "LiteralInfinity", + "LiteralInteger", + "LiteralRational", + "LiteralString", + "LoopActionUsage", + "METAMODEL_VERSION", + "Membership", + "MembershipExpose", + "MembershipImport", + "MergeNode", + "Metaclass", + "MetadataAccessExpression", + "MetadataDefinition", + "MetadataFeature", + "MetadataUsage", + "Multiplicity", + "MultiplicityRange", + "Namespace", + "NamespaceExpose", + "NamespaceImport", + "NullExpression", + "ObjectiveMembership", + "OccurrenceDefinition", + "OccurrenceUsage", + "OperatorExpression", + "OwningMembership", + "Package", + "ParameterMembership", + "PartDefinition", + "PartUsage", + "PayloadFeature", + "PerformActionUsage", + "PortConjugation", + "PortDefinition", + "PortUsage", + "PortionKind", + "Predicate", + "REGISTRY", + "RUNTIME_MEMBERS", + "Redefinition", + "ReferenceSubsetting", + "ReferenceUsage", + "Relationship", + "RenderingDefinition", + "RenderingUsage", + "RequirementConstraintKind", + "RequirementConstraintMembership", + "RequirementDefinition", + "RequirementUsage", + "RequirementVerificationMembership", + "ResultExpressionMembership", + "ReturnParameterMembership", + "SOURCE_COMMIT", + "SOURCE_TAG", + "SatisfyRequirementUsage", + "SelectExpression", + "SendActionUsage", + "Specialization", + "StakeholderMembership", + "StateDefinition", + "StateSubactionKind", + "StateSubactionMembership", + "StateUsage", + "Step", + "Structure", + "Subclassification", + "SubjectMembership", + "Subsetting", + "Succession", + "SuccessionAsUsage", + "SuccessionFlow", + "SuccessionFlowUsage", + "TerminateActionUsage", + "TextualRepresentation", + "TransitionFeatureKind", + "TransitionFeatureMembership", + "TransitionUsage", + "TriggerInvocationExpression", + "TriggerKind", + "Type", + "TypeFeaturing", + "Unioning", + "Usage", + "UseCaseDefinition", + "UseCaseUsage", + "VariantMembership", + "VerificationCaseDefinition", + "VerificationCaseUsage", + "ViewDefinition", + "ViewRenderingMembership", + "ViewUsage", + "ViewpointDefinition", + "ViewpointUsage", + "VisibilityKind", + "WhileLoopActionUsage", +] diff --git a/client/python/opensysml/metamodel/_reader.py b/client/python/opensysml/metamodel/_reader.py new file mode 100644 index 0000000000..c533dfb75e --- /dev/null +++ b/client/python/opensysml/metamodel/_reader.py @@ -0,0 +1,227 @@ +"""Read exported API or toolkit JSON into a lazy element graph.""" + +from __future__ import annotations + +import json +import os +import re +from collections.abc import Iterator, Mapping, Sequence +from pathlib import Path +from typing import Any, TypeVar, cast, overload + +from ._generated import REGISTRY, Element, Namespace +from ._runtime import MalformedDocument + +_E = TypeVar("_E", bound=Element) +_VERSIONED_SYSML = re.compile(r"^https://www\.omg\.org/spec/SysML/\d{8}/") +_SYSML_BASE = "https://www.omg.org/spec/SysML#" + + +def read_json( + source: str | os.PathLike[str] | bytes | bytearray | memoryview + | Sequence[Mapping[str, Any]] | Mapping[str, Any], + *, + supertypes: Mapping[str, str] | None = None, + check_ranges: bool = True, +) -> ElementGraph: + """Read an exported JSON document; strings and paths name files, not JSON text.""" + value = _read_source(source) + if isinstance(value, Mapping): + document = cast(Mapping[str, Any], value) + changes = document.get("change") + if isinstance(changes, list): + items = _unwrap_items(cast(Sequence[Any], changes)) + else: + items = _unwrap_items([document]) + elif isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)): + items = _unwrap_items(_as_sequence(value)) + else: + raise MalformedDocument("document must be an object or an array of elements") + return ElementGraph(items, supertypes=supertypes, check_ranges=check_ranges) + + +def _read_source( + source: str | os.PathLike[str] | bytes | bytearray | memoryview + | Sequence[Mapping[str, Any]] | Mapping[str, Any], +) -> Any: + if isinstance(source, (str, os.PathLike)): + data = Path(source).read_bytes() + return _decode(data) + if isinstance(source, (bytes, bytearray, memoryview)): + return _decode(bytes(source)) + return source + + +def _decode(data: bytes) -> Any: + try: + return json.loads(data) + except (UnicodeDecodeError, json.JSONDecodeError) as error: + raise MalformedDocument(f"invalid JSON document: {error}") from error + + +def _as_sequence(value: Any) -> Sequence[Any]: + return cast(Sequence[Any], value) + + +def _unwrap_items(items: Sequence[Any]) -> list[dict[str, Any]]: + result: list[dict[str, Any]] = [] + for item in items: + if not isinstance(item, Mapping): + raise MalformedDocument("each document element must be an object") + document = cast(Mapping[str, Any], item) + if "identity" in document and "payload" in document: + payload = document["payload"] + if payload is None: + continue + if not isinstance(payload, Mapping): + raise MalformedDocument("envelope payload must be an object or null") + result.append(dict(cast(Mapping[str, Any], payload))) + else: + result.append(dict(document)) + return result + + +class ElementGraph: + """Indexed document elements with lazy, cached metaclass wrappers.""" + + __slots__ = ( + "_data_by_id", + "_order", + "_cache", + "_supertypes", + "_check_ranges", + "_roots", + ) + + def __init__( + self, + elements: Sequence[Mapping[str, Any]], + *, + supertypes: Mapping[str, str] | None = None, + check_ranges: bool = True, + ) -> None: + data_by_id: dict[str, dict[str, Any]] = {} + order: list[str] = [] + for element in elements: + element_id = element.get("@id") + element_type = element.get("@type") + if not isinstance(element_id, str): + raise MalformedDocument("element is missing a string @id") + if not isinstance(element_type, str): + raise MalformedDocument(f"element {element_id} is missing a string @type") + if element_id in data_by_id: + raise MalformedDocument(f"duplicate element @id {element_id!r}") + data_by_id[element_id] = dict(element) + order.append(element_id) + self._data_by_id = data_by_id + self._order = tuple(order) + self._cache: dict[str, Element] = {} + self._supertypes = supertypes or {} + self._check_ranges = check_ranges + self._roots: tuple[Namespace, ...] | None = None + + def __getitem__(self, element_id: str) -> Element: + if element_id not in self._data_by_id: + raise KeyError(element_id) + cached = self._cache.get(element_id) + if cached is not None: + return cached + data = self._data_by_id[element_id] + metaclass = _metaclass(data["@type"], self._supertypes) + element = metaclass(self, data) + self._cache[element_id] = element + return element + + def get(self, element_id: str, default: Any = None) -> Element | Any: + if element_id not in self._data_by_id: + return default + return self[element_id] + + def __contains__(self, element_id: object) -> bool: + return isinstance(element_id, str) and element_id in self._data_by_id + + def __len__(self) -> int: + return len(self._order) + + @property + def check_ranges(self) -> bool: + """Whether reference targets are checked against declared metaclass ranges.""" + return self._check_ranges + + def __iter__(self) -> Iterator[Element]: + for element_id in self._order: + yield self[element_id] + + @overload + def all(self) -> tuple[Element, ...]: ... + + @overload + def all(self, cls: type[_E]) -> tuple[_E, ...]: ... + + def all(self, cls: type[_E] | None = None) -> tuple[Element, ...] | tuple[_E, ...]: + elements = tuple(self[element_id] for element_id in self._order) + if cls is None: + return elements + return tuple(element for element in elements if isinstance(element, cls)) + + def roots(self) -> tuple[Namespace, ...]: + if self._roots is not None: + return self._roots + referenced: set[str] = set() + for data in self._data_by_id.values(): + for key in ("ownedRelationship", "ownedRelatedElement"): + referenced.update(_reference_ids(data.get(key))) + self._roots = tuple( + element + for element in self + if isinstance(element, Namespace) + and all( + self._data_by_id[element.json_id].get(key) is None + for key in ("owningRelationship", "owner", "owningNamespace") + ) + and element.json_id not in referenced + ) + return self._roots + + +def _metaclass( + written_type: str, supertypes: Mapping[str, str] +) -> type[Element]: + name = _normalize_type(written_type) + seen: set[str] = set() + while True: + if name in REGISTRY: + return REGISTRY[name] + if name in seen: + raise MalformedDocument(f"supertype cycle while resolving {written_type!r}") + seen.add(name) + parent = supertypes.get(name) + if parent is None: + return Element + name = _normalize_type(parent) + + +def _normalize_type(written_type: str) -> str: + if written_type.startswith("sysml:"): + return written_type[len("sysml:") :] + if written_type.startswith(_SYSML_BASE): + return written_type[len(_SYSML_BASE) :] + return _VERSIONED_SYSML.sub("", written_type, count=1) + + +def _reference_ids(value: Any) -> set[str]: + if isinstance(value, Mapping): + mapping = cast(Mapping[str, Any], value) + element_id = mapping.get("@id") + if isinstance(element_id, str): + return {element_id} + result: set[str] = set() + for child in mapping.values(): + result.update(_reference_ids(child)) + return result + if isinstance(value, list): + result = set() + for child in _as_sequence(value): + result.update(_reference_ids(child)) + return result + return set() diff --git a/client/python/opensysml/metamodel/_runtime.py b/client/python/opensysml/metamodel/_runtime.py new file mode 100644 index 0000000000..6cd18c7305 --- /dev/null +++ b/client/python/opensysml/metamodel/_runtime.py @@ -0,0 +1,356 @@ +"""Runtime descriptors and errors for generated metamodel classes.""" + +from __future__ import annotations + +import math +from inspect import getattr_static +from types import MappingProxyType +from typing import TYPE_CHECKING, Any, ClassVar, Generic, Mapping, TypeVar, cast, overload + +from opensysml.errors import OpenSysMLError + +if TYPE_CHECKING: + from ._reader import ElementGraph + +T = TypeVar("T") + + +def _as_json_list(value: Any) -> list[Any]: + return cast(list[Any], value) + + +class _UnresolvedExpectedRange: + pass + + +_UNRESOLVED_EXPECTED_RANGE = _UnresolvedExpectedRange() + + +class MetamodelError(OpenSysMLError): + """Base class for errors raised while reading metamodel JSON.""" + + +class NotSupplied(MetamodelError): + """A property is absent from the JSON document.""" + + def __init__(self, property: str, key: str, element_id: str, derived: bool) -> None: + self.property = property + self.key = key + self.element_id = element_id + self.derived = derived + message = f'document carries no "{key}" for element {element_id}' + if derived: + message += "; owned-only exports omit derived properties" + super().__init__(message) + + +class UnresolvedReference(MetamodelError): + """A JSON reference does not resolve to an element in the document.""" + + def __init__( + self, + id: str | None, + ref: str | None, + property: str, + element_id: str, + ) -> None: + self.id = id + self.ref = ref + self.property = property + self.element_id = element_id + target = f"@id {id!r}" if id is not None else f"@ref {ref!r}" + super().__init__(f"{property} on element {element_id} refers to unresolved {target}") + + +class MalformedValue(MetamodelError): + """A property value does not match its declared metamodel range.""" + + +class MalformedDocument(MetamodelError, ValueError): + """The JSON document does not contain a valid element graph.""" + + +class UnknownJSONKey(MetamodelError, KeyError): + """A JSON key is not declared for a metaclass.""" + + def __init__(self, metaclass: str, key: str) -> None: + self.metaclass = metaclass + self.key = key + super().__init__(f"{metaclass} has no JSON property {key!r}") + + +class _ElementBase: + __slots__ = ("_graph", "_id", "_data", "_type") + + METACLASS: ClassVar[str] = "Element" + JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({}) + + def __init__(self, graph: ElementGraph, data: Mapping[str, Any]) -> None: + self._graph = graph + self._id = cast(str, data["@id"]) + self._data = data + self._type = cast(str, data["@type"]) + + @property + def json_id(self) -> str: + return self._id + + @property + def json_type(self) -> str: + return self._type + + @property + def metaclass_name(self) -> str: + return type(self).METACLASS + + @property + def graph(self) -> ElementGraph: + return self._graph + + def json_value(self, key: str) -> Any: + try: + return self._data[key] + except KeyError: + name = type(self).JSON_KEYS.get(key) + descriptor = getattr_static(type(self), name, None) if name is not None else None + derived = descriptor.derived if isinstance(descriptor, _Property) else False + raise NotSupplied( + f"{self.metaclass_name}.{key}", key, self.json_id, derived + ) from None + + @classmethod + def from_json_key(cls, key: str) -> str: + try: + return cls.JSON_KEYS[key] + except KeyError: + raise UnknownJSONKey(cls.METACLASS, key) from None + + @classmethod + def json_key(cls, name: str) -> str: + if name in cls.JSON_KEYS: + return name + for key, snake in cls.JSON_KEYS.items(): + if snake == name: + return key + raise UnknownJSONKey(cls.METACLASS, name) + + def __eq__(self, other: object) -> bool: + if not isinstance(other, _ElementBase): + return NotImplemented + return self._graph is other._graph and self._id == other._id + + def __hash__(self) -> int: + return hash((id(self._graph), self._id)) + + def __repr__(self) -> str: + name = self._data.get("declaredName") + suffix = f" declaredName={name!r}" if isinstance(name, str) else "" + return f"<{self.metaclass_name} {self._id!r}{suffix}>" + + +class _Property(Generic[T]): + __slots__ = ( + "key", + "range", + "ordered", + "derived", + "many", + "owner", + "_name", + "_expected_range", + ) + + def __init__( + self, + key: str, + range: str, + *, + ordered: bool = False, + derived: bool = False, + many: bool, + ) -> None: + self.key = key + self.range = range + self.ordered = ordered + self.derived = derived + self.many = many + self.owner: type[_ElementBase] | None = None + self._name: str | None = None + self._expected_range: ( + type[_ElementBase] | None | _UnresolvedExpectedRange + ) = _UNRESOLVED_EXPECTED_RANGE + + def __set_name__(self, owner: type[_ElementBase], name: str) -> None: + if self.owner is None: + self.owner = owner + self._name = name + + def __get__( + self, instance: _ElementBase | None, owner: type[Any] | None = None + ) -> Any: + if instance is None: + return self + try: + raw = instance.json_value(self.key) + except NotSupplied: + raise NotSupplied( + self._property(instance), self.key, instance.json_id, self.derived + ) from None + if self.many: + if raw is None: + return () + if not isinstance(raw, list): + raise self._malformed(instance, f"expected an array, got {raw!r}") + values: list[T] = [] + for item in _as_json_list(raw): + if item is None: + raise self._malformed(instance, "array contains null") + values.append(self._convert(item, instance)) + return tuple(values) + if raw is None: + return None + if isinstance(raw, list): + raise self._malformed(instance, f"expected a scalar, got {raw!r}") + return self._convert(raw, instance) + + def __set__(self, instance: _ElementBase, value: T) -> None: + raise AttributeError("metamodel properties are read-only") + + def __delete__(self, instance: _ElementBase) -> None: + raise AttributeError("metamodel properties are read-only") + + def _convert(self, value: Any, instance: _ElementBase) -> T: + if not isinstance(value, Mapping): + return self._primitive(value, instance) + reference = cast(Mapping[str, Any], value) + if "@ref" in reference: + ref = reference["@ref"] + if not isinstance(ref, str): + raise self._malformed(instance, f"@ref must be a string, got {ref!r}") + raise UnresolvedReference(None, ref, self._property(instance), instance.json_id) + if "@id" in reference: + element_id = reference["@id"] + if not isinstance(element_id, str): + raise self._malformed(instance, f"@id must be a string, got {element_id!r}") + try: + target = instance.graph[element_id] + except KeyError: + raise UnresolvedReference( + element_id, None, self._property(instance), instance.json_id + ) from None + if not instance.graph.check_ranges: + return cast(T, target) + expected = self._expected_metaclass() + if expected is not None and not isinstance(target, expected): + raise self._malformed( + instance, + f"reference target @id {element_id!r} has json_type " + f"{target.json_type!r}; expected {expected.METACLASS}; " + "pass supertypes=... for unknown @types", + ) + return cast(T, target) + raise self._malformed(instance, f"expected a reference object, got {value!r}") + + def _expected_metaclass(self) -> type[_ElementBase] | None: + expected = self._expected_range + if isinstance(expected, _UnresolvedExpectedRange): + from ._generated import REGISTRY + + expected = cast(type[_ElementBase] | None, REGISTRY.get(self.range)) + self._expected_range = expected + return expected + + def _primitive(self, value: Any, instance: _ElementBase) -> T: + if self.range == "bool": + if type(value) is not bool: + raise self._malformed(instance, f"expected bool, got {value!r}") + return cast(T, value) + if self.range == "str": + if not isinstance(value, str): + raise self._malformed(instance, f"expected str, got {value!r}") + return cast(T, value) + if self.range == "int": + if type(value) is not int: + raise self._malformed(instance, f"expected int, got {value!r}") + return cast(T, value) + if self.range == "float": + if type(value) not in (int, float): + raise self._malformed(instance, f"expected float, got {value!r}") + try: + converted = float(value) + except OverflowError: + raise self._malformed( + instance, f"expected a finite float, got {value!r}" + ) from None + if not math.isfinite(converted): + raise self._malformed( + instance, f"expected a finite float, got {value!r}" + ) + return cast(T, converted) + + from ._generated import ENUMERATIONS + + enum = ENUMERATIONS.get(self.range) + if enum is not None: + try: + return cast(T, enum(value)) + except (TypeError, ValueError): + raise self._malformed( + instance, f"{value!r} is not a {self.range} literal" + ) from None + raise self._malformed( + instance, f"expected a reference to {self.range}, got {value!r}" + ) + + def _property(self, instance: _ElementBase) -> str: + return f"{instance.metaclass_name}.{self.key}" + + def _malformed(self, instance: _ElementBase, reason: str) -> MalformedValue: + return MalformedValue(f"{self._property(instance)} on element {instance.json_id}: {reason}") + + +class Opt(_Property[T], Generic[T]): + """A read-only, optional single-valued metamodel property.""" + + def __init__(self, key: str, range: str, *, derived: bool = False) -> None: + super().__init__(key, range, derived=derived, many=False) + + @overload + def __get__(self, instance: None, owner: type[Any] | None = None) -> Opt[T]: ... + + @overload + def __get__( + self, instance: _ElementBase, owner: type[Any] | None = None + ) -> T | None: ... + + def __get__( + self, instance: _ElementBase | None, owner: type[Any] | None = None + ) -> Opt[T] | T | None: + return cast(Opt[T] | T | None, super().__get__(instance, owner)) + + +class Many(_Property[T], Generic[T]): + """A read-only, tuple-valued metamodel property.""" + + def __init__( + self, + key: str, + range: str, + *, + ordered: bool = False, + derived: bool = False, + ) -> None: + super().__init__(key, range, ordered=ordered, derived=derived, many=True) + + @overload + def __get__(self, instance: None, owner: type[Any] | None = None) -> Many[T]: ... + + @overload + def __get__( + self, instance: _ElementBase, owner: type[Any] | None = None + ) -> tuple[T, ...]: ... + + def __get__( + self, instance: _ElementBase | None, owner: type[Any] | None = None + ) -> Many[T] | tuple[T, ...]: + return cast(Many[T] | tuple[T, ...], super().__get__(instance, owner)) diff --git a/client/python/pyproject.toml b/client/python/pyproject.toml index 219abee5ea..68ec4cf3ed 100644 --- a/client/python/pyproject.toml +++ b/client/python/pyproject.toml @@ -105,4 +105,3 @@ warn_unused_ignores = true [[tool.mypy.overrides]] module = ["fmpy", "fmpy.*"] ignore_missing_imports = true - diff --git a/client/python/tests/fixtures/metamodel/README.md b/client/python/tests/fixtures/metamodel/README.md new file mode 100644 index 0000000000..f09a18755a --- /dev/null +++ b/client/python/tests/fixtures/metamodel/README.md @@ -0,0 +1,9 @@ +# SysML toolkit JSON fixture + +`bigger.sysml` is copied from [Open-MBEE/sysml-sdk](https://github.com/Open-MBEE/sysml-sdk/blob/main/data/bigger.sysml), +which is distributed under the Apache License 2.0 (see that repository's `LICENSE`). +`bigger.full.json` was generated with sysmlv2 0.10.0: + +```sh +sysmlv2 convert bigger.sysml --to full-json -o bigger.full.json +``` diff --git a/client/python/tests/fixtures/metamodel/bigger.full.json b/client/python/tests/fixtures/metamodel/bigger.full.json new file mode 100644 index 0000000000..4cce052d03 --- /dev/null +++ b/client/python/tests/fixtures/metamodel/bigger.full.json @@ -0,0 +1,8722 @@ +[ + { + "@id": "285a9918-092d-5a42-a72b-91ee2bd95de0", + "@type": "Namespace", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "285a9918-092d-5a42-a72b-91ee2bd95de0", + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + } + ], + "membership": [ + { + "@id": "ed5cfe08-9915-5edf-b1fe-7681c2f83c1c" + } + ], + "name": null, + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + } + ], + "ownedMembership": [ + { + "@id": "ed5cfe08-9915-5edf-b1fe-7681c2f83c1c" + } + ], + "ownedRelationship": [ + { + "@id": "ed5cfe08-9915-5edf-b1fe-7681c2f83c1c" + } + ], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelationship": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "ed5cfe08-9915-5edf-b1fe-7681c2f83c1c", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "ed5cfe08-9915-5edf-b1fe-7681c2f83c1c", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "memberElementId": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd", + "memberName": "Demo", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "285a9918-092d-5a42-a72b-91ee2bd95de0" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "ownedMemberElementId": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd", + "ownedMemberName": "Demo", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "285a9918-092d-5a42-a72b-91ee2bd95de0" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "285a9918-092d-5a42-a72b-91ee2bd95de0" + }, + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + } + ], + "shortName": null, + "source": [ + { + "@id": "285a9918-092d-5a42-a72b-91ee2bd95de0" + } + ], + "target": [ + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd", + "@type": "Package", + "aliasIds": [], + "declaredName": "Demo", + "declaredShortName": null, + "documentation": [], + "elementId": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd", + "filterCondition": [], + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + } + ], + "membership": [ + { + "@id": "096458d9-a7bd-58ed-b9d1-7f307928a556" + }, + { + "@id": "5f787fd2-287f-5f88-aca4-8ffbe85cd6d5" + }, + { + "@id": "6c7132c6-1869-51a7-bef2-17ba0aa84e41" + } + ], + "name": "Demo", + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + } + ], + "ownedMembership": [ + { + "@id": "096458d9-a7bd-58ed-b9d1-7f307928a556" + }, + { + "@id": "5f787fd2-287f-5f88-aca4-8ffbe85cd6d5" + }, + { + "@id": "6c7132c6-1869-51a7-bef2-17ba0aa84e41" + } + ], + "ownedRelationship": [ + { + "@id": "096458d9-a7bd-58ed-b9d1-7f307928a556" + }, + { + "@id": "5f787fd2-287f-5f88-aca4-8ffbe85cd6d5" + }, + { + "@id": "6c7132c6-1869-51a7-bef2-17ba0aa84e41" + } + ], + "owner": { + "@id": "285a9918-092d-5a42-a72b-91ee2bd95de0" + }, + "owningMembership": { + "@id": "ed5cfe08-9915-5edf-b1fe-7681c2f83c1c" + }, + "owningNamespace": { + "@id": "285a9918-092d-5a42-a72b-91ee2bd95de0" + }, + "owningRelationship": { + "@id": "ed5cfe08-9915-5edf-b1fe-7681c2f83c1c" + }, + "qualifiedName": "Demo", + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "096458d9-a7bd-58ed-b9d1-7f307928a556", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "096458d9-a7bd-58ed-b9d1-7f307928a556", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + "memberElementId": "059144fc-05f1-5ebf-8bfb-e61df17a5344", + "memberName": "Base", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + "ownedMemberElementId": "059144fc-05f1-5ebf-8bfb-e61df17a5344", + "ownedMemberName": "Base", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + } + ], + "shortName": null, + "source": [ + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + } + ], + "target": [ + { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "Base", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "059144fc-05f1-5ebf-8bfb-e61df17a5344", + "endFeature": [], + "feature": [ + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + } + ], + "featureMembership": [ + { + "@id": "2e318e4b-32c4-5a5a-a57b-d1bde5c34137" + } + ], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [ + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + } + ], + "membership": [ + { + "@id": "2e318e4b-32c4-5a5a-a57b-d1bde5c34137" + } + ], + "multiplicity": null, + "name": "Base", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [ + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + } + ], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + } + ], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [ + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + } + ], + "ownedFeatureMembership": [ + { + "@id": "2e318e4b-32c4-5a5a-a57b-d1bde5c34137" + } + ], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [ + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + } + ], + "ownedMembership": [ + { + "@id": "2e318e4b-32c4-5a5a-a57b-d1bde5c34137" + } + ], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "2e318e4b-32c4-5a5a-a57b-d1bde5c34137" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [], + "ownedState": [], + "ownedSubclassification": [], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [ + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + } + ], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "owningMembership": { + "@id": "096458d9-a7bd-58ed-b9d1-7f307928a556" + }, + "owningNamespace": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "owningRelationship": { + "@id": "096458d9-a7bd-58ed-b9d1-7f307928a556" + }, + "qualifiedName": "Demo::Base", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [ + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "2e318e4b-32c4-5a5a-a57b-d1bde5c34137", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "2e318e4b-32c4-5a5a-a57b-d1bde5c34137", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + }, + "memberElementId": "e5e61b9e-98ea-51db-8790-5985464366aa", + "memberName": "mass", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + }, + "ownedMemberElementId": "e5e61b9e-98ea-51db-8790-5985464366aa", + "ownedMemberFeature": { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + }, + "ownedMemberName": "mass", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + "owningRelationship": null, + "owningType": { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + } + ], + "shortName": null, + "source": [ + { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + } + ], + "target": [ + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa", + "@type": "AttributeUsage", + "aliasIds": [], + "attributeDefinition": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "mass", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "e5e61b9e-98ea-51db-8790-5985464366aa", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "e5e61b9e-98ea-51db-8790-5985464366aa" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "mass", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + "owningDefinition": { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + "owningFeatureMembership": { + "@id": "2e318e4b-32c4-5a5a-a57b-d1bde5c34137" + }, + "owningMembership": { + "@id": "2e318e4b-32c4-5a5a-a57b-d1bde5c34137" + }, + "owningNamespace": { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + "owningRelationship": { + "@id": "2e318e4b-32c4-5a5a-a57b-d1bde5c34137" + }, + "owningType": { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + "owningUsage": null, + "qualifiedName": "Demo::Base::mass", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "5f787fd2-287f-5f88-aca4-8ffbe85cd6d5", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5f787fd2-287f-5f88-aca4-8ffbe85cd6d5", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "memberElementId": "ad6f1824-1aac-5411-9735-6059195938de", + "memberName": "Vehicle", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "ownedMemberElementId": "ad6f1824-1aac-5411-9735-6059195938de", + "ownedMemberName": "Vehicle", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "shortName": null, + "source": [ + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + } + ], + "target": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "Vehicle", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "ad6f1824-1aac-5411-9735-6059195938de", + "endFeature": [], + "feature": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + } + ], + "featureMembership": [ + { + "@id": "b1f6db7c-3a25-5710-80c3-e5b6c41318ef" + }, + { + "@id": "d4715362-5372-5d2c-9cd1-b1a1e4def3f3" + }, + { + "@id": "03b44cfd-826e-5bbe-ab94-41c547cb6e85" + }, + { + "@id": "291dc6c2-0ff7-5c3d-a382-24421fe7f366" + }, + { + "@id": "a1fd3155-f550-520d-922d-7364576a7c19" + }, + { + "@id": "dacb44f6-dce6-57a9-bd32-fe4fb7876f36" + }, + { + "@id": "eca34046-824d-57c3-a8a0-2db822304a82" + } + ], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + }, + { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + } + ], + "membership": [ + { + "@id": "b1f6db7c-3a25-5710-80c3-e5b6c41318ef" + }, + { + "@id": "d4715362-5372-5d2c-9cd1-b1a1e4def3f3" + }, + { + "@id": "03b44cfd-826e-5bbe-ab94-41c547cb6e85" + }, + { + "@id": "291dc6c2-0ff7-5c3d-a382-24421fe7f366" + }, + { + "@id": "a1fd3155-f550-520d-922d-7364576a7c19" + }, + { + "@id": "dacb44f6-dce6-57a9-bd32-fe4fb7876f36" + }, + { + "@id": "eca34046-824d-57c3-a8a0-2db822304a82" + }, + { + "@id": "5adae87a-b9b5-5fe6-9af7-b053274a8c24" + } + ], + "multiplicity": null, + "name": "Vehicle", + "output": [], + "ownedAction": [ + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + } + ], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + } + ], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [ + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + } + ], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + }, + { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + } + ], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + } + ], + "ownedFeatureMembership": [ + { + "@id": "b1f6db7c-3a25-5710-80c3-e5b6c41318ef" + }, + { + "@id": "d4715362-5372-5d2c-9cd1-b1a1e4def3f3" + }, + { + "@id": "03b44cfd-826e-5bbe-ab94-41c547cb6e85" + }, + { + "@id": "291dc6c2-0ff7-5c3d-a382-24421fe7f366" + }, + { + "@id": "a1fd3155-f550-520d-922d-7364576a7c19" + }, + { + "@id": "dacb44f6-dce6-57a9-bd32-fe4fb7876f36" + }, + { + "@id": "eca34046-824d-57c3-a8a0-2db822304a82" + } + ], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [ + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + } + ], + "ownedMember": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + }, + { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + } + ], + "ownedMembership": [ + { + "@id": "b1f6db7c-3a25-5710-80c3-e5b6c41318ef" + }, + { + "@id": "d4715362-5372-5d2c-9cd1-b1a1e4def3f3" + }, + { + "@id": "03b44cfd-826e-5bbe-ab94-41c547cb6e85" + }, + { + "@id": "291dc6c2-0ff7-5c3d-a382-24421fe7f366" + }, + { + "@id": "a1fd3155-f550-520d-922d-7364576a7c19" + }, + { + "@id": "dacb44f6-dce6-57a9-bd32-fe4fb7876f36" + }, + { + "@id": "eca34046-824d-57c3-a8a0-2db822304a82" + }, + { + "@id": "5adae87a-b9b5-5fe6-9af7-b053274a8c24" + } + ], + "ownedMetadata": [], + "ownedOccurrence": [ + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + } + ], + "ownedPart": [ + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + } + ], + "ownedPort": [ + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + } + ], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "d44a140f-8dbb-5c21-851c-5f2bdf5d590d" + }, + { + "@id": "b1f6db7c-3a25-5710-80c3-e5b6c41318ef" + }, + { + "@id": "d4715362-5372-5d2c-9cd1-b1a1e4def3f3" + }, + { + "@id": "03b44cfd-826e-5bbe-ab94-41c547cb6e85" + }, + { + "@id": "291dc6c2-0ff7-5c3d-a382-24421fe7f366" + }, + { + "@id": "a1fd3155-f550-520d-922d-7364576a7c19" + }, + { + "@id": "dacb44f6-dce6-57a9-bd32-fe4fb7876f36" + }, + { + "@id": "eca34046-824d-57c3-a8a0-2db822304a82" + }, + { + "@id": "5adae87a-b9b5-5fe6-9af7-b053274a8c24" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "d44a140f-8dbb-5c21-851c-5f2bdf5d590d" + } + ], + "ownedState": [ + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + } + ], + "ownedSubclassification": [ + { + "@id": "d44a140f-8dbb-5c21-851c-5f2bdf5d590d" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + } + ], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "owningMembership": { + "@id": "5f787fd2-287f-5f88-aca4-8ffbe85cd6d5" + }, + "owningNamespace": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "owningRelationship": { + "@id": "5f787fd2-287f-5f88-aca4-8ffbe85cd6d5" + }, + "qualifiedName": "Demo::Vehicle", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "d44a140f-8dbb-5c21-851c-5f2bdf5d590d", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d44a140f-8dbb-5c21-851c-5f2bdf5d590d", + "general": { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": null, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + } + ], + "shortName": null, + "source": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "specific": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "subclassifier": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "superclassifier": { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + }, + "target": [ + { + "@id": "059144fc-05f1-5ebf-8bfb-e61df17a5344" + } + ], + "textualRepresentation": [] + }, + { + "@id": "b1f6db7c-3a25-5710-80c3-e5b6c41318ef", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "b1f6db7c-3a25-5710-80c3-e5b6c41318ef", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "memberElementId": "97792196-6134-52ec-a21b-b518697e0ae9", + "memberName": "mass2", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "ownedMemberElementId": "97792196-6134-52ec-a21b-b518697e0ae9", + "ownedMemberFeature": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "ownedMemberName": "mass2", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": null, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + } + ], + "shortName": null, + "source": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "target": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9", + "@type": "AttributeUsage", + "aliasIds": [], + "attributeDefinition": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "mass2", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "97792196-6134-52ec-a21b-b518697e0ae9", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "mass2", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningDefinition": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningFeatureMembership": { + "@id": "b1f6db7c-3a25-5710-80c3-e5b6c41318ef" + }, + "owningMembership": { + "@id": "b1f6db7c-3a25-5710-80c3-e5b6c41318ef" + }, + "owningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": { + "@id": "b1f6db7c-3a25-5710-80c3-e5b6c41318ef" + }, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningUsage": null, + "qualifiedName": "Demo::Vehicle::mass2", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "d4715362-5372-5d2c-9cd1-b1a1e4def3f3", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d4715362-5372-5d2c-9cd1-b1a1e4def3f3", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + "memberElementId": "f0a07c31-c7fc-5354-8690-4087a409059a", + "memberName": "wheel", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + "ownedMemberElementId": "f0a07c31-c7fc-5354-8690-4087a409059a", + "ownedMemberFeature": { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + "ownedMemberName": "wheel", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": null, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + } + ], + "shortName": null, + "source": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "target": [ + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a", + "@type": "PartUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "wheel", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "f0a07c31-c7fc-5354-8690-4087a409059a", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "itemDefinition": [], + "mayTimeVary": null, + "member": [ + { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + } + ], + "membership": [ + { + "@id": "94596295-c669-57ae-9bdb-80543d457de2" + } + ], + "multiplicity": { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + }, + "name": "wheel", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + } + ], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + } + ], + "ownedMembership": [ + { + "@id": "94596295-c669-57ae-9bdb-80543d457de2" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "94596295-c669-57ae-9bdb-80543d457de2" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningDefinition": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningFeatureMembership": { + "@id": "d4715362-5372-5d2c-9cd1-b1a1e4def3f3" + }, + "owningMembership": { + "@id": "d4715362-5372-5d2c-9cd1-b1a1e4def3f3" + }, + "owningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": { + "@id": "d4715362-5372-5d2c-9cd1-b1a1e4def3f3" + }, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningUsage": null, + "partDefinition": [], + "portionKind": null, + "qualifiedName": "Demo::Vehicle::wheel", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "94596295-c669-57ae-9bdb-80543d457de2", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "94596295-c669-57ae-9bdb-80543d457de2", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + }, + "memberElementId": "4bb1d6dc-7671-53d3-815d-da907bb6445c", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + }, + "ownedMemberElementId": "4bb1d6dc-7671-53d3-815d-da907bb6445c", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + } + ], + "shortName": null, + "source": [ + { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + } + ], + "target": [ + { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c", + "@type": "MultiplicityRange", + "aliasIds": [], + "bound": [ + { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + } + ], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "4bb1d6dc-7671-53d3-815d-da907bb6445c", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "lowerBound": null, + "member": [ + { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + } + ], + "membership": [ + { + "@id": "854c254a-ad1c-5d31-88bc-405ea5405212" + } + ], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + } + ], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + } + ], + "ownedMembership": [ + { + "@id": "854c254a-ad1c-5d31-88bc-405ea5405212" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "854c254a-ad1c-5d31-88bc-405ea5405212" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "94596295-c669-57ae-9bdb-80543d457de2" + }, + "owningNamespace": { + "@id": "f0a07c31-c7fc-5354-8690-4087a409059a" + }, + "owningRelationship": { + "@id": "94596295-c669-57ae-9bdb-80543d457de2" + }, + "owningType": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "upperBound": { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + } + }, + { + "@id": "854c254a-ad1c-5d31-88bc-405ea5405212", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "854c254a-ad1c-5d31-88bc-405ea5405212", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + }, + "memberElementId": "62b51846-59f5-5351-8dac-529d799485bf", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + }, + "ownedMemberElementId": "62b51846-59f5-5351-8dac-529d799485bf", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + }, + { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + } + ], + "shortName": null, + "source": [ + { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + } + ], + "target": [ + { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "62b51846-59f5-5351-8dac-529d799485bf", + "@type": "LiteralInteger", + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "62b51846-59f5-5351-8dac-529d799485bf", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + }, + "featuringType": [], + "function": null, + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isModelLevelEvaluable": true, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "854c254a-ad1c-5d31-88bc-405ea5405212" + }, + "owningNamespace": { + "@id": "4bb1d6dc-7671-53d3-815d-da907bb6445c" + }, + "owningRelationship": { + "@id": "854c254a-ad1c-5d31-88bc-405ea5405212" + }, + "owningType": null, + "parameter": [], + "qualifiedName": null, + "result": { + "@id": "62b51846-59f5-5351-8dac-529d799485bf" + }, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "value": 4 + }, + { + "@id": "03b44cfd-826e-5bbe-ab94-41c547cb6e85", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "03b44cfd-826e-5bbe-ab94-41c547cb6e85", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + "memberElementId": "c9a6db9c-29da-5127-b186-e81f1e68924d", + "memberName": "p", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + "ownedMemberElementId": "c9a6db9c-29da-5127-b186-e81f1e68924d", + "ownedMemberFeature": { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + "ownedMemberName": "p", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": null, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + } + ], + "shortName": null, + "source": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "target": [ + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d", + "@type": "PortUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "p", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "c9a6db9c-29da-5127-b186-e81f1e68924d", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "c9a6db9c-29da-5127-b186-e81f1e68924d" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "p", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningDefinition": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningFeatureMembership": { + "@id": "03b44cfd-826e-5bbe-ab94-41c547cb6e85" + }, + "owningMembership": { + "@id": "03b44cfd-826e-5bbe-ab94-41c547cb6e85" + }, + "owningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": { + "@id": "03b44cfd-826e-5bbe-ab94-41c547cb6e85" + }, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningUsage": null, + "portDefinition": [], + "portionKind": null, + "qualifiedName": "Demo::Vehicle::p", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "291dc6c2-0ff7-5c3d-a382-24421fe7f366", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "291dc6c2-0ff7-5c3d-a382-24421fe7f366", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + "memberElementId": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca", + "memberName": "cargo", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + "ownedMemberElementId": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca", + "ownedMemberFeature": { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + "ownedMemberName": "cargo", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": null, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + } + ], + "shortName": null, + "source": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "target": [ + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca", + "@type": "ItemUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "cargo", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "8ddc80e4-36e2-5e09-897d-e33dd9d055ca" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "itemDefinition": [], + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "cargo", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningDefinition": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningFeatureMembership": { + "@id": "291dc6c2-0ff7-5c3d-a382-24421fe7f366" + }, + "owningMembership": { + "@id": "291dc6c2-0ff7-5c3d-a382-24421fe7f366" + }, + "owningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": { + "@id": "291dc6c2-0ff7-5c3d-a382-24421fe7f366" + }, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningUsage": null, + "portionKind": null, + "qualifiedName": "Demo::Vehicle::cargo", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "a1fd3155-f550-520d-922d-7364576a7c19", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "a1fd3155-f550-520d-922d-7364576a7c19", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + "memberElementId": "c7f610e0-e0bb-5542-b121-88b40c159129", + "memberName": "a", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + "ownedMemberElementId": "c7f610e0-e0bb-5542-b121-88b40c159129", + "ownedMemberFeature": { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + "ownedMemberName": "a", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": null, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + } + ], + "shortName": null, + "source": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "target": [ + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129", + "@type": "ActionUsage", + "actionDefinition": [], + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "a", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "c7f610e0-e0bb-5542-b121-88b40c159129", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "c7f610e0-e0bb-5542-b121-88b40c159129" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "a", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningDefinition": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningFeatureMembership": { + "@id": "a1fd3155-f550-520d-922d-7364576a7c19" + }, + "owningMembership": { + "@id": "a1fd3155-f550-520d-922d-7364576a7c19" + }, + "owningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": { + "@id": "a1fd3155-f550-520d-922d-7364576a7c19" + }, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningUsage": null, + "parameter": [], + "portionKind": null, + "qualifiedName": "Demo::Vehicle::a", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "dacb44f6-dce6-57a9-bd32-fe4fb7876f36", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "dacb44f6-dce6-57a9-bd32-fe4fb7876f36", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + "memberElementId": "404a82ff-0899-5719-bb15-8c04912dbc0b", + "memberName": "c", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + "ownedMemberElementId": "404a82ff-0899-5719-bb15-8c04912dbc0b", + "ownedMemberFeature": { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + "ownedMemberName": "c", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": null, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + } + ], + "shortName": null, + "source": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "target": [ + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b", + "@type": "ConstraintUsage", + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "constraintDefinition": null, + "crossFeature": null, + "declaredName": "c", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "404a82ff-0899-5719-bb15-8c04912dbc0b", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + } + ], + "featureMembership": [ + { + "@id": "45764250-7503-5815-abfa-dc553954a6a7" + } + ], + "featureTarget": { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + "featuringType": [], + "function": null, + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isModelLevelEvaluable": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + } + ], + "membership": [ + { + "@id": "45764250-7503-5815-abfa-dc553954a6a7" + } + ], + "multiplicity": null, + "name": "c", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "45764250-7503-5815-abfa-dc553954a6a7" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + } + ], + "ownedMembership": [ + { + "@id": "45764250-7503-5815-abfa-dc553954a6a7" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "45764250-7503-5815-abfa-dc553954a6a7" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningDefinition": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningFeatureMembership": { + "@id": "dacb44f6-dce6-57a9-bd32-fe4fb7876f36" + }, + "owningMembership": { + "@id": "dacb44f6-dce6-57a9-bd32-fe4fb7876f36" + }, + "owningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": { + "@id": "dacb44f6-dce6-57a9-bd32-fe4fb7876f36" + }, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningUsage": null, + "parameter": [], + "portionKind": null, + "predicate": null, + "qualifiedName": "Demo::Vehicle::c", + "result": { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "45764250-7503-5815-abfa-dc553954a6a7", + "@type": "ResultExpressionMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "45764250-7503-5815-abfa-dc553954a6a7", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "memberElementId": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "ownedMemberElementId": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d", + "ownedMemberFeature": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + } + ], + "ownedRelationship": [], + "ownedResultExpression": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + "owningRelationship": null, + "owningType": { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + } + ], + "shortName": null, + "source": [ + { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + } + ], + "target": [ + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d", + "@type": "OperatorExpression", + "aliasIds": [], + "argument": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + } + ], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "direction": null, + "documentation": [], + "elementId": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "featureMembership": [ + { + "@id": "b304e8b5-8b4b-5df3-89b9-12e4356497c7" + }, + { + "@id": "f2400c4e-84c2-5fb1-a9fd-57e5a2755df3" + } + ], + "featureTarget": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "featuringType": [], + "function": null, + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "instantiatedType": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isModelLevelEvaluable": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "membership": [ + { + "@id": "b304e8b5-8b4b-5df3-89b9-12e4356497c7" + }, + { + "@id": "f2400c4e-84c2-5fb1-a9fd-57e5a2755df3" + } + ], + "multiplicity": null, + "name": null, + "operator": ">", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "b304e8b5-8b4b-5df3-89b9-12e4356497c7" + }, + { + "@id": "f2400c4e-84c2-5fb1-a9fd-57e5a2755df3" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "ownedMembership": [ + { + "@id": "b304e8b5-8b4b-5df3-89b9-12e4356497c7" + }, + { + "@id": "f2400c4e-84c2-5fb1-a9fd-57e5a2755df3" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "b304e8b5-8b4b-5df3-89b9-12e4356497c7" + }, + { + "@id": "f2400c4e-84c2-5fb1-a9fd-57e5a2755df3" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + "owningFeatureMembership": { + "@id": "45764250-7503-5815-abfa-dc553954a6a7" + }, + "owningMembership": { + "@id": "45764250-7503-5815-abfa-dc553954a6a7" + }, + "owningNamespace": { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + "owningRelationship": { + "@id": "45764250-7503-5815-abfa-dc553954a6a7" + }, + "owningType": { + "@id": "404a82ff-0899-5719-bb15-8c04912dbc0b" + }, + "parameter": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "qualifiedName": null, + "result": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "b304e8b5-8b4b-5df3-89b9-12e4356497c7", + "@type": "ParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "b304e8b5-8b4b-5df3-89b9-12e4356497c7", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + "memberElementId": "ba278114-75c8-511d-930c-1fbf03b380f7", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + "ownedMemberElementId": "ba278114-75c8-511d-930c-1fbf03b380f7", + "ownedMemberFeature": { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + "ownedMemberName": null, + "ownedMemberParameter": { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "owningRelationship": null, + "owningType": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + } + ], + "shortName": null, + "source": [ + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + } + ], + "target": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + } + ], + "textualRepresentation": [], + "visibility": "private" + }, + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": "in", + "documentation": [], + "elementId": "ba278114-75c8-511d-930c-1fbf03b380f7", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + } + ], + "membership": [ + { + "@id": "fc840ceb-1ac6-5f74-bd0a-c76d5c1b402a" + } + ], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + } + ], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + } + ], + "ownedMembership": [ + { + "@id": "fc840ceb-1ac6-5f74-bd0a-c76d5c1b402a" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "fc840ceb-1ac6-5f74-bd0a-c76d5c1b402a" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "owningFeatureMembership": { + "@id": "b304e8b5-8b4b-5df3-89b9-12e4356497c7" + }, + "owningMembership": { + "@id": "b304e8b5-8b4b-5df3-89b9-12e4356497c7" + }, + "owningNamespace": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "owningRelationship": { + "@id": "b304e8b5-8b4b-5df3-89b9-12e4356497c7" + }, + "owningType": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "fc840ceb-1ac6-5f74-bd0a-c76d5c1b402a", + "@type": "FeatureValue", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "fc840ceb-1ac6-5f74-bd0a-c76d5c1b402a", + "featureWithValue": { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + "isDefault": false, + "isImplied": false, + "isImpliedIncluded": true, + "isInitial": false, + "isLibraryElement": false, + "memberElement": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "memberElementId": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "ownedMemberElementId": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + } + ], + "shortName": null, + "source": [ + { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + } + ], + "target": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + } + ], + "textualRepresentation": [], + "value": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "visibility": "public" + }, + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95", + "@type": "FeatureReferenceExpression", + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "direction": null, + "documentation": [], + "elementId": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "featureMembership": [ + { + "@id": "a15430f8-7da3-5c52-96a9-e7d5c6b17995" + } + ], + "featureTarget": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "featuringType": [], + "function": null, + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isModelLevelEvaluable": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "membership": [ + { + "@id": "94ed74ea-624f-5487-8428-0bf2bc0ae73e" + }, + { + "@id": "a15430f8-7da3-5c52-96a9-e7d5c6b17995" + }, + { + "@id": "c407a02c-8f34-5850-8210-ffce76da2658" + } + ], + "multiplicity": null, + "name": null, + "output": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "a15430f8-7da3-5c52-96a9-e7d5c6b17995" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "ownedMembership": [ + { + "@id": "94ed74ea-624f-5487-8428-0bf2bc0ae73e" + }, + { + "@id": "a15430f8-7da3-5c52-96a9-e7d5c6b17995" + }, + { + "@id": "c407a02c-8f34-5850-8210-ffce76da2658" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "94ed74ea-624f-5487-8428-0bf2bc0ae73e" + }, + { + "@id": "a15430f8-7da3-5c52-96a9-e7d5c6b17995" + }, + { + "@id": "c407a02c-8f34-5850-8210-ffce76da2658" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "fc840ceb-1ac6-5f74-bd0a-c76d5c1b402a" + }, + "owningNamespace": { + "@id": "ba278114-75c8-511d-930c-1fbf03b380f7" + }, + "owningRelationship": { + "@id": "fc840ceb-1ac6-5f74-bd0a-c76d5c1b402a" + }, + "owningType": null, + "parameter": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "qualifiedName": null, + "referent": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "result": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "94ed74ea-624f-5487-8428-0bf2bc0ae73e", + "@type": "Membership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "94ed74ea-624f-5487-8428-0bf2bc0ae73e", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "memberElementId": "97792196-6134-52ec-a21b-b518697e0ae9", + "memberName": "mass2", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + } + ], + "shortName": null, + "source": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + } + ], + "target": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "f2400c4e-84c2-5fb1-a9fd-57e5a2755df3", + "@type": "ParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f2400c4e-84c2-5fb1-a9fd-57e5a2755df3", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + }, + "memberElementId": "f466beff-5e1e-58d4-9f60-aa8e5395989f", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + }, + "ownedMemberElementId": "f466beff-5e1e-58d4-9f60-aa8e5395989f", + "ownedMemberFeature": { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + }, + "ownedMemberName": null, + "ownedMemberParameter": { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "owningRelationship": null, + "owningType": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "shortName": null, + "source": [ + { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + } + ], + "target": [ + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "textualRepresentation": [], + "visibility": "private" + }, + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": "in", + "documentation": [], + "elementId": "f466beff-5e1e-58d4-9f60-aa8e5395989f", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + } + ], + "membership": [ + { + "@id": "11d8c607-cfae-537d-858a-4e3b3c1e58e1" + } + ], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + } + ], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + } + ], + "ownedMembership": [ + { + "@id": "11d8c607-cfae-537d-858a-4e3b3c1e58e1" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "11d8c607-cfae-537d-858a-4e3b3c1e58e1" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "owningFeatureMembership": { + "@id": "f2400c4e-84c2-5fb1-a9fd-57e5a2755df3" + }, + "owningMembership": { + "@id": "f2400c4e-84c2-5fb1-a9fd-57e5a2755df3" + }, + "owningNamespace": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "owningRelationship": { + "@id": "f2400c4e-84c2-5fb1-a9fd-57e5a2755df3" + }, + "owningType": { + "@id": "4f9afd4a-5f0a-5b53-aea9-11bf1f41765d" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "11d8c607-cfae-537d-858a-4e3b3c1e58e1", + "@type": "FeatureValue", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "11d8c607-cfae-537d-858a-4e3b3c1e58e1", + "featureWithValue": { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + }, + "isDefault": false, + "isImplied": false, + "isImpliedIncluded": true, + "isInitial": false, + "isLibraryElement": false, + "memberElement": { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + }, + "memberElementId": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + }, + "ownedMemberElementId": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + }, + { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + } + ], + "shortName": null, + "source": [ + { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + } + ], + "target": [ + { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + } + ], + "textualRepresentation": [], + "value": { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + }, + "visibility": "public" + }, + { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b", + "@type": "LiteralInteger", + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + }, + "featuringType": [], + "function": null, + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isModelLevelEvaluable": true, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "11d8c607-cfae-537d-858a-4e3b3c1e58e1" + }, + "owningNamespace": { + "@id": "f466beff-5e1e-58d4-9f60-aa8e5395989f" + }, + "owningRelationship": { + "@id": "11d8c607-cfae-537d-858a-4e3b3c1e58e1" + }, + "owningType": null, + "parameter": [], + "qualifiedName": null, + "result": { + "@id": "6fb2ae58-ee0d-5d2a-aae0-1160e3b7ff8b" + }, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "value": 0 + }, + { + "@id": "eca34046-824d-57c3-a8a0-2db822304a82", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "eca34046-824d-57c3-a8a0-2db822304a82", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + }, + "memberElementId": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0", + "memberName": "s", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + }, + "ownedMemberElementId": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0", + "ownedMemberFeature": { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + }, + "ownedMemberName": "s", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": null, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + } + ], + "shortName": null, + "source": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "target": [ + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0", + "@type": "StateUsage", + "actionDefinition": [], + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "s", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "doAction": null, + "documentation": [], + "elementId": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0", + "endFeature": [], + "endOwningType": null, + "entryAction": null, + "exitAction": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "ad7ab666-b6f4-5e4a-844e-b24f68bcdcd0" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isParallel": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "s", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningDefinition": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningFeatureMembership": { + "@id": "eca34046-824d-57c3-a8a0-2db822304a82" + }, + "owningMembership": { + "@id": "eca34046-824d-57c3-a8a0-2db822304a82" + }, + "owningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": { + "@id": "eca34046-824d-57c3-a8a0-2db822304a82" + }, + "owningType": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningUsage": null, + "parameter": [], + "portionKind": null, + "qualifiedName": "Demo::Vehicle::s", + "shortName": null, + "stateDefinition": [], + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "5adae87a-b9b5-5fe6-9af7-b053274a8c24", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5adae87a-b9b5-5fe6-9af7-b053274a8c24", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "memberElementId": "2912f365-4259-5157-b2b7-d52d94aa3274", + "memberName": "K", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "ownedMemberElementId": "2912f365-4259-5157-b2b7-d52d94aa3274", + "ownedMemberName": "K", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + } + ], + "shortName": null, + "source": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "target": [ + { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274", + "@type": "CalculationDefinition", + "action": [], + "aliasIds": [], + "calculation": [], + "declaredName": "K", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "directedUsage": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "documentation": [], + "elementId": "2912f365-4259-5157-b2b7-d52d94aa3274", + "endFeature": [], + "expression": [], + "feature": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "featureMembership": [ + { + "@id": "a355397c-11f9-5058-a508-82c04de10f2c" + }, + { + "@id": "71413f5f-b749-5c39-b364-d36fef32d3cd" + } + ], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + } + ], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isModelLevelEvaluable": false, + "isSufficient": false, + "isVariation": false, + "member": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "membership": [ + { + "@id": "a355397c-11f9-5058-a508-82c04de10f2c" + }, + { + "@id": "71413f5f-b749-5c39-b364-d36fef32d3cd" + } + ], + "multiplicity": null, + "name": "K", + "output": [ + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "ownedFeatureMembership": [ + { + "@id": "a355397c-11f9-5058-a508-82c04de10f2c" + }, + { + "@id": "71413f5f-b749-5c39-b364-d36fef32d3cd" + } + ], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "ownedMembership": [ + { + "@id": "a355397c-11f9-5058-a508-82c04de10f2c" + }, + { + "@id": "71413f5f-b749-5c39-b364-d36fef32d3cd" + } + ], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "ownedRelationship": [ + { + "@id": "a355397c-11f9-5058-a508-82c04de10f2c" + }, + { + "@id": "71413f5f-b749-5c39-b364-d36fef32d3cd" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [], + "ownedState": [], + "ownedSubclassification": [], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningMembership": { + "@id": "5adae87a-b9b5-5fe6-9af7-b053274a8c24" + }, + "owningNamespace": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "owningRelationship": { + "@id": "5adae87a-b9b5-5fe6-9af7-b053274a8c24" + }, + "parameter": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "qualifiedName": "Demo::Vehicle::K", + "result": { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + "shortName": null, + "step": [], + "textualRepresentation": [], + "unioningType": [], + "usage": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "a355397c-11f9-5058-a508-82c04de10f2c", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "a355397c-11f9-5058-a508-82c04de10f2c", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "memberElementId": "4d296856-56cf-54fe-af9d-f911a1632d55", + "memberName": "x", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "ownedMemberElementId": "4d296856-56cf-54fe-af9d-f911a1632d55", + "ownedMemberFeature": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "ownedMemberName": "x", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "owningRelationship": null, + "owningType": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + } + ], + "shortName": null, + "source": [ + { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + } + ], + "target": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "x", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": "in", + "documentation": [], + "elementId": "4d296856-56cf-54fe-af9d-f911a1632d55", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "x", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "owningDefinition": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "owningFeatureMembership": { + "@id": "a355397c-11f9-5058-a508-82c04de10f2c" + }, + "owningMembership": { + "@id": "a355397c-11f9-5058-a508-82c04de10f2c" + }, + "owningNamespace": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "owningRelationship": { + "@id": "a355397c-11f9-5058-a508-82c04de10f2c" + }, + "owningType": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "owningUsage": null, + "qualifiedName": "Demo::Vehicle::K::x", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "71413f5f-b749-5c39-b364-d36fef32d3cd", + "@type": "ReturnParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "71413f5f-b749-5c39-b364-d36fef32d3cd", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + "memberElementId": "90d04899-eacb-53cc-b8f3-cc954c5715f2", + "memberName": "y", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + "ownedMemberElementId": "90d04899-eacb-53cc-b8f3-cc954c5715f2", + "ownedMemberFeature": { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + "ownedMemberName": "y", + "ownedMemberParameter": { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "owningRelationship": null, + "owningType": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "shortName": null, + "source": [ + { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + } + ], + "target": [ + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "y", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": "out", + "documentation": [], + "elementId": "90d04899-eacb-53cc-b8f3-cc954c5715f2", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + } + ], + "membership": [ + { + "@id": "5cec300f-0798-5eeb-ab2e-4bd12958c6fb" + } + ], + "multiplicity": null, + "name": "y", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + } + ], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + } + ], + "ownedMembership": [ + { + "@id": "5cec300f-0798-5eeb-ab2e-4bd12958c6fb" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "5cec300f-0798-5eeb-ab2e-4bd12958c6fb" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "owningDefinition": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "owningFeatureMembership": { + "@id": "71413f5f-b749-5c39-b364-d36fef32d3cd" + }, + "owningMembership": { + "@id": "71413f5f-b749-5c39-b364-d36fef32d3cd" + }, + "owningNamespace": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "owningRelationship": { + "@id": "71413f5f-b749-5c39-b364-d36fef32d3cd" + }, + "owningType": { + "@id": "2912f365-4259-5157-b2b7-d52d94aa3274" + }, + "owningUsage": null, + "qualifiedName": "Demo::Vehicle::K::y", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "5cec300f-0798-5eeb-ab2e-4bd12958c6fb", + "@type": "FeatureValue", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5cec300f-0798-5eeb-ab2e-4bd12958c6fb", + "featureWithValue": { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + "isDefault": false, + "isImplied": false, + "isImpliedIncluded": true, + "isInitial": false, + "isLibraryElement": false, + "memberElement": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "memberElementId": "069d6128-4cea-50ad-871e-0be8f61eab28", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "ownedMemberElementId": "069d6128-4cea-50ad-871e-0be8f61eab28", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + } + ], + "shortName": null, + "source": [ + { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + } + ], + "target": [ + { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + } + ], + "textualRepresentation": [], + "value": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "visibility": "public" + }, + { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28", + "@type": "OperatorExpression", + "aliasIds": [], + "argument": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + } + ], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "direction": null, + "documentation": [], + "elementId": "069d6128-4cea-50ad-871e-0be8f61eab28", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "featureMembership": [ + { + "@id": "4b76481f-dd9f-590e-9fe6-e4dca46ff217" + }, + { + "@id": "b4a2c714-b418-5f2f-86fc-26e2d0a68919" + } + ], + "featureTarget": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "featuringType": [], + "function": null, + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "instantiatedType": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isModelLevelEvaluable": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "membership": [ + { + "@id": "4b76481f-dd9f-590e-9fe6-e4dca46ff217" + }, + { + "@id": "b4a2c714-b418-5f2f-86fc-26e2d0a68919" + } + ], + "multiplicity": null, + "name": null, + "operator": "+", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "4b76481f-dd9f-590e-9fe6-e4dca46ff217" + }, + { + "@id": "b4a2c714-b418-5f2f-86fc-26e2d0a68919" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "ownedMembership": [ + { + "@id": "4b76481f-dd9f-590e-9fe6-e4dca46ff217" + }, + { + "@id": "b4a2c714-b418-5f2f-86fc-26e2d0a68919" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "4b76481f-dd9f-590e-9fe6-e4dca46ff217" + }, + { + "@id": "b4a2c714-b418-5f2f-86fc-26e2d0a68919" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "5cec300f-0798-5eeb-ab2e-4bd12958c6fb" + }, + "owningNamespace": { + "@id": "90d04899-eacb-53cc-b8f3-cc954c5715f2" + }, + "owningRelationship": { + "@id": "5cec300f-0798-5eeb-ab2e-4bd12958c6fb" + }, + "owningType": null, + "parameter": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "qualifiedName": null, + "result": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "4b76481f-dd9f-590e-9fe6-e4dca46ff217", + "@type": "ParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "4b76481f-dd9f-590e-9fe6-e4dca46ff217", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + "memberElementId": "b2f4906d-c847-56e8-8697-a577ca5c0f24", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + "ownedMemberElementId": "b2f4906d-c847-56e8-8697-a577ca5c0f24", + "ownedMemberFeature": { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + "ownedMemberName": null, + "ownedMemberParameter": { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "owningRelationship": null, + "owningType": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + } + ], + "shortName": null, + "source": [ + { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + } + ], + "target": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + } + ], + "textualRepresentation": [], + "visibility": "private" + }, + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": "in", + "documentation": [], + "elementId": "b2f4906d-c847-56e8-8697-a577ca5c0f24", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + } + ], + "membership": [ + { + "@id": "2fd5c8e2-d257-5bda-9e78-890f278e7b5a" + } + ], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + } + ], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + } + ], + "ownedMembership": [ + { + "@id": "2fd5c8e2-d257-5bda-9e78-890f278e7b5a" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "2fd5c8e2-d257-5bda-9e78-890f278e7b5a" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "owningFeatureMembership": { + "@id": "4b76481f-dd9f-590e-9fe6-e4dca46ff217" + }, + "owningMembership": { + "@id": "4b76481f-dd9f-590e-9fe6-e4dca46ff217" + }, + "owningNamespace": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "owningRelationship": { + "@id": "4b76481f-dd9f-590e-9fe6-e4dca46ff217" + }, + "owningType": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "2fd5c8e2-d257-5bda-9e78-890f278e7b5a", + "@type": "FeatureValue", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "2fd5c8e2-d257-5bda-9e78-890f278e7b5a", + "featureWithValue": { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + "isDefault": false, + "isImplied": false, + "isImpliedIncluded": true, + "isInitial": false, + "isLibraryElement": false, + "memberElement": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "memberElementId": "194e4d05-8812-5619-aaa2-06d4a3680e3a", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "ownedMemberElementId": "194e4d05-8812-5619-aaa2-06d4a3680e3a", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + } + ], + "shortName": null, + "source": [ + { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + } + ], + "target": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + } + ], + "textualRepresentation": [], + "value": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "visibility": "public" + }, + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a", + "@type": "FeatureReferenceExpression", + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "direction": null, + "documentation": [], + "elementId": "194e4d05-8812-5619-aaa2-06d4a3680e3a", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "featureMembership": [ + { + "@id": "38930d49-5a3f-5436-a749-5ea0ee8668ef" + } + ], + "featureTarget": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "featuringType": [], + "function": null, + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isModelLevelEvaluable": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "membership": [ + { + "@id": "0ad33a22-158c-56e2-bc96-931d9b999e86" + }, + { + "@id": "38930d49-5a3f-5436-a749-5ea0ee8668ef" + }, + { + "@id": "d8724770-1f07-5b54-83e6-f7ebc56ada57" + } + ], + "multiplicity": null, + "name": null, + "output": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "38930d49-5a3f-5436-a749-5ea0ee8668ef" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "ownedMembership": [ + { + "@id": "0ad33a22-158c-56e2-bc96-931d9b999e86" + }, + { + "@id": "38930d49-5a3f-5436-a749-5ea0ee8668ef" + }, + { + "@id": "d8724770-1f07-5b54-83e6-f7ebc56ada57" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "0ad33a22-158c-56e2-bc96-931d9b999e86" + }, + { + "@id": "38930d49-5a3f-5436-a749-5ea0ee8668ef" + }, + { + "@id": "d8724770-1f07-5b54-83e6-f7ebc56ada57" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "2fd5c8e2-d257-5bda-9e78-890f278e7b5a" + }, + "owningNamespace": { + "@id": "b2f4906d-c847-56e8-8697-a577ca5c0f24" + }, + "owningRelationship": { + "@id": "2fd5c8e2-d257-5bda-9e78-890f278e7b5a" + }, + "owningType": null, + "parameter": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "qualifiedName": null, + "referent": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "result": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "0ad33a22-158c-56e2-bc96-931d9b999e86", + "@type": "Membership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "0ad33a22-158c-56e2-bc96-931d9b999e86", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "memberElementId": "4d296856-56cf-54fe-af9d-f911a1632d55", + "memberName": "x", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + } + ], + "shortName": null, + "source": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + } + ], + "target": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "b4a2c714-b418-5f2f-86fc-26e2d0a68919", + "@type": "ParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "b4a2c714-b418-5f2f-86fc-26e2d0a68919", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + }, + "memberElementId": "145eda2a-410f-5b86-ab8b-a296ce4d56bf", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + }, + "ownedMemberElementId": "145eda2a-410f-5b86-ab8b-a296ce4d56bf", + "ownedMemberFeature": { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + }, + "ownedMemberName": null, + "ownedMemberParameter": { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "owningRelationship": null, + "owningType": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "shortName": null, + "source": [ + { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + } + ], + "target": [ + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "textualRepresentation": [], + "visibility": "private" + }, + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": "in", + "documentation": [], + "elementId": "145eda2a-410f-5b86-ab8b-a296ce4d56bf", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + } + ], + "membership": [ + { + "@id": "0c9c3218-19fa-55b0-b863-e41bb8ad26f8" + } + ], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + } + ], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + } + ], + "ownedMembership": [ + { + "@id": "0c9c3218-19fa-55b0-b863-e41bb8ad26f8" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "0c9c3218-19fa-55b0-b863-e41bb8ad26f8" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "owningFeatureMembership": { + "@id": "b4a2c714-b418-5f2f-86fc-26e2d0a68919" + }, + "owningMembership": { + "@id": "b4a2c714-b418-5f2f-86fc-26e2d0a68919" + }, + "owningNamespace": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "owningRelationship": { + "@id": "b4a2c714-b418-5f2f-86fc-26e2d0a68919" + }, + "owningType": { + "@id": "069d6128-4cea-50ad-871e-0be8f61eab28" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "0c9c3218-19fa-55b0-b863-e41bb8ad26f8", + "@type": "FeatureValue", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "0c9c3218-19fa-55b0-b863-e41bb8ad26f8", + "featureWithValue": { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + }, + "isDefault": false, + "isImplied": false, + "isImpliedIncluded": true, + "isInitial": false, + "isLibraryElement": false, + "memberElement": { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + }, + "memberElementId": "6c377fd8-df1a-520c-b72e-1a679b73a73e", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + }, + "ownedMemberElementId": "6c377fd8-df1a-520c-b72e-1a679b73a73e", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + }, + { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + } + ], + "shortName": null, + "source": [ + { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + } + ], + "target": [ + { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + } + ], + "textualRepresentation": [], + "value": { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + }, + "visibility": "public" + }, + { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e", + "@type": "LiteralInteger", + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "6c377fd8-df1a-520c-b72e-1a679b73a73e", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + }, + "featuringType": [], + "function": null, + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isModelLevelEvaluable": true, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "0c9c3218-19fa-55b0-b863-e41bb8ad26f8" + }, + "owningNamespace": { + "@id": "145eda2a-410f-5b86-ab8b-a296ce4d56bf" + }, + "owningRelationship": { + "@id": "0c9c3218-19fa-55b0-b863-e41bb8ad26f8" + }, + "owningType": null, + "parameter": [], + "qualifiedName": null, + "result": { + "@id": "6c377fd8-df1a-520c-b72e-1a679b73a73e" + }, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "value": 1 + }, + { + "@id": "6c7132c6-1869-51a7-bef2-17ba0aa84e41", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "6c7132c6-1869-51a7-bef2-17ba0aa84e41", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + }, + "memberElementId": "e654e8fb-c916-5202-9fb8-31c07e907c29", + "memberName": "v", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + }, + "ownedMemberElementId": "e654e8fb-c916-5202-9fb8-31c07e907c29", + "ownedMemberName": "v", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + } + ], + "shortName": null, + "source": [ + { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + } + ], + "target": [ + { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29", + "@type": "PartUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "v", + "declaredShortName": null, + "definition": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "e654e8fb-c916-5202-9fb8-31c07e907c29", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "itemDefinition": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "v", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "81ac951c-13b9-5ca8-ae2f-514103df420b" + } + ], + "ownedSpecialization": [ + { + "@id": "81ac951c-13b9-5ca8-ae2f-514103df420b" + } + ], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "81ac951c-13b9-5ca8-ae2f-514103df420b" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "owningDefinition": null, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "6c7132c6-1869-51a7-bef2-17ba0aa84e41" + }, + "owningNamespace": { + "@id": "41ba6746-fd6d-54c7-bfbc-1519ed9a00cd" + }, + "owningRelationship": { + "@id": "6c7132c6-1869-51a7-bef2-17ba0aa84e41" + }, + "owningType": null, + "owningUsage": null, + "partDefinition": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "portionKind": null, + "qualifiedName": "Demo::v", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "81ac951c-13b9-5ca8-ae2f-514103df420b", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "81ac951c-13b9-5ca8-ae2f-514103df420b", + "general": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + }, + "owningRelationship": null, + "owningType": { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + }, + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "shortName": null, + "source": [ + { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + } + ], + "specific": { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + }, + "target": [ + { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + } + ], + "textualRepresentation": [], + "type": { + "@id": "ad6f1824-1aac-5411-9735-6059195938de" + }, + "typedFeature": { + "@id": "e654e8fb-c916-5202-9fb8-31c07e907c29" + } + }, + { + "@id": "a15430f8-7da3-5c52-96a9-e7d5c6b17995", + "@type": "ReturnParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "a15430f8-7da3-5c52-96a9-e7d5c6b17995", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "memberElementId": "33290348-f6bd-5855-89fc-cfdd6ff953ea", + "memberName": "result", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "ownedMemberElementId": "33290348-f6bd-5855-89fc-cfdd6ff953ea", + "ownedMemberFeature": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "ownedMemberName": "result", + "ownedMemberParameter": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "owningRelationship": null, + "owningType": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "shortName": null, + "source": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + } + ], + "target": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": "out", + "documentation": [], + "elementId": "33290348-f6bd-5855-89fc-cfdd6ff953ea", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "result", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "a2dcc83d-bfea-5766-bbe2-72d10e37be6b" + }, + { + "@id": "ed7e1240-40b7-51d5-b8ef-4cdbbe8053d3" + } + ], + "ownedSpecialization": [ + { + "@id": "a2dcc83d-bfea-5766-bbe2-72d10e37be6b" + } + ], + "ownedSubsetting": [ + { + "@id": "a2dcc83d-bfea-5766-bbe2-72d10e37be6b" + } + ], + "ownedTypeFeaturing": [ + { + "@id": "ed7e1240-40b7-51d5-b8ef-4cdbbe8053d3" + } + ], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "owningFeatureMembership": { + "@id": "a15430f8-7da3-5c52-96a9-e7d5c6b17995" + }, + "owningMembership": { + "@id": "a15430f8-7da3-5c52-96a9-e7d5c6b17995" + }, + "owningNamespace": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "owningRelationship": { + "@id": "a15430f8-7da3-5c52-96a9-e7d5c6b17995" + }, + "owningType": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "a2dcc83d-bfea-5766-bbe2-72d10e37be6b", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "a2dcc83d-bfea-5766-bbe2-72d10e37be6b", + "general": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "owningRelationship": null, + "owningType": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + } + ], + "shortName": null, + "source": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "specific": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "subsettedFeature": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "subsettingFeature": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "target": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + } + ], + "textualRepresentation": [] + }, + { + "@id": "ed7e1240-40b7-51d5-b8ef-4cdbbe8053d3", + "@type": "TypeFeaturing", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "ed7e1240-40b7-51d5-b8ef-4cdbbe8053d3", + "featureOfType": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "featuringType": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeatureOfType": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + } + ], + "shortName": null, + "source": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "target": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + } + ], + "textualRepresentation": [] + }, + { + "@id": "c407a02c-8f34-5850-8210-ffce76da2658", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "c407a02c-8f34-5850-8210-ffce76da2658", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "memberElementId": "b2c73881-e0c8-561c-942c-e501beb0caad", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "ownedMemberElementId": "b2c73881-e0c8-561c-942c-e501beb0caad", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "shortName": null, + "source": [ + { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + } + ], + "target": [ + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad", + "@type": "BindingConnector", + "aliasIds": [], + "association": [], + "chainingFeature": [], + "connectorEnd": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "defaultFeaturingType": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "b2c73881-e0c8-561c-942c-e501beb0caad", + "endFeature": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "endOwningType": null, + "feature": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "featureMembership": [ + { + "@id": "1453274a-3586-5f98-95fb-cae84f792294" + }, + { + "@id": "c7697452-a2c5-5676-99fb-3e8cfc808608" + } + ], + "featureTarget": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "membership": [ + { + "@id": "1453274a-3586-5f98-95fb-cae84f792294" + }, + { + "@id": "c7697452-a2c5-5676-99fb-3e8cfc808608" + } + ], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "ownedEndFeature": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "ownedFeature": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "1453274a-3586-5f98-95fb-cae84f792294" + }, + { + "@id": "c7697452-a2c5-5676-99fb-3e8cfc808608" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "ownedMembership": [ + { + "@id": "1453274a-3586-5f98-95fb-cae84f792294" + }, + { + "@id": "c7697452-a2c5-5676-99fb-3e8cfc808608" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelatedElement": [], + "ownedRelationship": [ + { + "@id": "1453274a-3586-5f98-95fb-cae84f792294" + }, + { + "@id": "c7697452-a2c5-5676-99fb-3e8cfc808608" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "c407a02c-8f34-5850-8210-ffce76da2658" + }, + "owningNamespace": { + "@id": "2fd0b7b3-d1b6-57bd-ab70-9dbccc816c95" + }, + "owningRelatedElement": null, + "owningRelationship": { + "@id": "c407a02c-8f34-5850-8210-ffce76da2658" + }, + "owningType": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "relatedFeature": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "shortName": null, + "source": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + } + ], + "sourceFeature": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "target": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "targetFeature": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "1453274a-3586-5f98-95fb-cae84f792294", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "1453274a-3586-5f98-95fb-cae84f792294", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "memberElementId": "5741743d-ad5b-59b9-ac2b-bbc53899270d", + "memberName": "thisThing", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "ownedMemberElementId": "5741743d-ad5b-59b9-ac2b-bbc53899270d", + "ownedMemberFeature": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "ownedMemberName": "thisThing", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "owningRelationship": null, + "owningType": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + } + ], + "shortName": null, + "source": [ + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "target": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "5741743d-ad5b-59b9-ac2b-bbc53899270d", + "endFeature": [], + "endOwningType": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "thisThing", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": { + "@id": "3941ce64-d7b3-5cd0-ba1b-e5010f00d415" + }, + "ownedRelationship": [ + { + "@id": "3941ce64-d7b3-5cd0-ba1b-e5010f00d415" + }, + { + "@id": "5967a1b5-b760-5328-aa11-f34325255159" + } + ], + "ownedSpecialization": [ + { + "@id": "3941ce64-d7b3-5cd0-ba1b-e5010f00d415" + } + ], + "ownedSubsetting": [ + { + "@id": "3941ce64-d7b3-5cd0-ba1b-e5010f00d415" + } + ], + "ownedTypeFeaturing": [ + { + "@id": "5967a1b5-b760-5328-aa11-f34325255159" + } + ], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "owningFeatureMembership": { + "@id": "1453274a-3586-5f98-95fb-cae84f792294" + }, + "owningMembership": { + "@id": "1453274a-3586-5f98-95fb-cae84f792294" + }, + "owningNamespace": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "owningRelationship": { + "@id": "1453274a-3586-5f98-95fb-cae84f792294" + }, + "owningType": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "3941ce64-d7b3-5cd0-ba1b-e5010f00d415", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "3941ce64-d7b3-5cd0-ba1b-e5010f00d415", + "general": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "owningRelationship": null, + "owningType": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "referencingFeature": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "relatedElement": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + } + ], + "shortName": null, + "source": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + } + ], + "specific": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "subsettedFeature": { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + }, + "subsettingFeature": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "target": [ + { + "@id": "97792196-6134-52ec-a21b-b518697e0ae9" + } + ], + "textualRepresentation": [] + }, + { + "@id": "5967a1b5-b760-5328-aa11-f34325255159", + "@type": "TypeFeaturing", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5967a1b5-b760-5328-aa11-f34325255159", + "featureOfType": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "featuringType": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeatureOfType": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + }, + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "shortName": null, + "source": [ + { + "@id": "5741743d-ad5b-59b9-ac2b-bbc53899270d" + } + ], + "target": [ + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "textualRepresentation": [] + }, + { + "@id": "c7697452-a2c5-5676-99fb-3e8cfc808608", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "c7697452-a2c5-5676-99fb-3e8cfc808608", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "memberElementId": "18e9ab29-df75-560e-84d9-14a6679b93c7", + "memberName": "sameThing", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "ownedMemberElementId": "18e9ab29-df75-560e-84d9-14a6679b93c7", + "ownedMemberFeature": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "ownedMemberName": "sameThing", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "owningRelationship": null, + "owningType": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "shortName": null, + "source": [ + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "target": [ + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "18e9ab29-df75-560e-84d9-14a6679b93c7", + "endFeature": [], + "endOwningType": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "sameThing", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": { + "@id": "f9c66178-3639-503f-97de-4b77f5eafe4e" + }, + "ownedRelationship": [ + { + "@id": "f9c66178-3639-503f-97de-4b77f5eafe4e" + }, + { + "@id": "f02bd7bb-0f9a-574a-a68c-27012130f739" + } + ], + "ownedSpecialization": [ + { + "@id": "f9c66178-3639-503f-97de-4b77f5eafe4e" + } + ], + "ownedSubsetting": [ + { + "@id": "f9c66178-3639-503f-97de-4b77f5eafe4e" + } + ], + "ownedTypeFeaturing": [ + { + "@id": "f02bd7bb-0f9a-574a-a68c-27012130f739" + } + ], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "owningFeatureMembership": { + "@id": "c7697452-a2c5-5676-99fb-3e8cfc808608" + }, + "owningMembership": { + "@id": "c7697452-a2c5-5676-99fb-3e8cfc808608" + }, + "owningNamespace": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "owningRelationship": { + "@id": "c7697452-a2c5-5676-99fb-3e8cfc808608" + }, + "owningType": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "f9c66178-3639-503f-97de-4b77f5eafe4e", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f9c66178-3639-503f-97de-4b77f5eafe4e", + "general": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "owningRelationship": null, + "owningType": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "referencingFeature": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "relatedElement": [ + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "shortName": null, + "source": [ + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "specific": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "subsettedFeature": { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + }, + "subsettingFeature": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "target": [ + { + "@id": "33290348-f6bd-5855-89fc-cfdd6ff953ea" + } + ], + "textualRepresentation": [] + }, + { + "@id": "f02bd7bb-0f9a-574a-a68c-27012130f739", + "@type": "TypeFeaturing", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f02bd7bb-0f9a-574a-a68c-27012130f739", + "featureOfType": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "featuringType": { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeatureOfType": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + }, + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "shortName": null, + "source": [ + { + "@id": "18e9ab29-df75-560e-84d9-14a6679b93c7" + } + ], + "target": [ + { + "@id": "b2c73881-e0c8-561c-942c-e501beb0caad" + } + ], + "textualRepresentation": [] + }, + { + "@id": "38930d49-5a3f-5436-a749-5ea0ee8668ef", + "@type": "ReturnParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "38930d49-5a3f-5436-a749-5ea0ee8668ef", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "memberElementId": "d1c72cc5-6726-548c-a08f-8c856be64f71", + "memberName": "result", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "ownedMemberElementId": "d1c72cc5-6726-548c-a08f-8c856be64f71", + "ownedMemberFeature": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "ownedMemberName": "result", + "ownedMemberParameter": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "owningRelationship": null, + "owningType": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "shortName": null, + "source": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + } + ], + "target": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": "out", + "documentation": [], + "elementId": "d1c72cc5-6726-548c-a08f-8c856be64f71", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "result", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "4c9cac68-9b27-5319-965a-4834c76619c7" + }, + { + "@id": "810d3723-3350-54bb-b11d-4448cd2e6be7" + } + ], + "ownedSpecialization": [ + { + "@id": "4c9cac68-9b27-5319-965a-4834c76619c7" + } + ], + "ownedSubsetting": [ + { + "@id": "4c9cac68-9b27-5319-965a-4834c76619c7" + } + ], + "ownedTypeFeaturing": [ + { + "@id": "810d3723-3350-54bb-b11d-4448cd2e6be7" + } + ], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "owningFeatureMembership": { + "@id": "38930d49-5a3f-5436-a749-5ea0ee8668ef" + }, + "owningMembership": { + "@id": "38930d49-5a3f-5436-a749-5ea0ee8668ef" + }, + "owningNamespace": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "owningRelationship": { + "@id": "38930d49-5a3f-5436-a749-5ea0ee8668ef" + }, + "owningType": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "4c9cac68-9b27-5319-965a-4834c76619c7", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "4c9cac68-9b27-5319-965a-4834c76619c7", + "general": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "owningRelationship": null, + "owningType": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + } + ], + "shortName": null, + "source": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "specific": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "subsettedFeature": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "subsettingFeature": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "target": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + } + ], + "textualRepresentation": [] + }, + { + "@id": "810d3723-3350-54bb-b11d-4448cd2e6be7", + "@type": "TypeFeaturing", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "810d3723-3350-54bb-b11d-4448cd2e6be7", + "featureOfType": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "featuringType": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeatureOfType": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + } + ], + "shortName": null, + "source": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "target": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + } + ], + "textualRepresentation": [] + }, + { + "@id": "d8724770-1f07-5b54-83e6-f7ebc56ada57", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d8724770-1f07-5b54-83e6-f7ebc56ada57", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "memberElementId": "3212075d-1f66-5781-aba0-bc1ae2fb36ff", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "ownedMemberElementId": "3212075d-1f66-5781-aba0-bc1ae2fb36ff", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "shortName": null, + "source": [ + { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + } + ], + "target": [ + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff", + "@type": "BindingConnector", + "aliasIds": [], + "association": [], + "chainingFeature": [], + "connectorEnd": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "defaultFeaturingType": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "3212075d-1f66-5781-aba0-bc1ae2fb36ff", + "endFeature": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "endOwningType": null, + "feature": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "featureMembership": [ + { + "@id": "5e81e92c-1411-596f-987c-880d9ea3e26a" + }, + { + "@id": "6a94b723-e9b9-599c-acde-e82b94e950c6" + } + ], + "featureTarget": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "membership": [ + { + "@id": "5e81e92c-1411-596f-987c-880d9ea3e26a" + }, + { + "@id": "6a94b723-e9b9-599c-acde-e82b94e950c6" + } + ], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "ownedEndFeature": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "ownedFeature": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "5e81e92c-1411-596f-987c-880d9ea3e26a" + }, + { + "@id": "6a94b723-e9b9-599c-acde-e82b94e950c6" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "ownedMembership": [ + { + "@id": "5e81e92c-1411-596f-987c-880d9ea3e26a" + }, + { + "@id": "6a94b723-e9b9-599c-acde-e82b94e950c6" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelatedElement": [], + "ownedRelationship": [ + { + "@id": "5e81e92c-1411-596f-987c-880d9ea3e26a" + }, + { + "@id": "6a94b723-e9b9-599c-acde-e82b94e950c6" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "d8724770-1f07-5b54-83e6-f7ebc56ada57" + }, + "owningNamespace": { + "@id": "194e4d05-8812-5619-aaa2-06d4a3680e3a" + }, + "owningRelatedElement": null, + "owningRelationship": { + "@id": "d8724770-1f07-5b54-83e6-f7ebc56ada57" + }, + "owningType": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "relatedFeature": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "shortName": null, + "source": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + } + ], + "sourceFeature": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "target": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "targetFeature": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "5e81e92c-1411-596f-987c-880d9ea3e26a", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5e81e92c-1411-596f-987c-880d9ea3e26a", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "memberElementId": "abf74499-4cb9-58d2-a324-1624000dc9ab", + "memberName": "thisThing", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "ownedMemberElementId": "abf74499-4cb9-58d2-a324-1624000dc9ab", + "ownedMemberFeature": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "ownedMemberName": "thisThing", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "owningRelationship": null, + "owningType": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + } + ], + "shortName": null, + "source": [ + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "target": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "abf74499-4cb9-58d2-a324-1624000dc9ab", + "endFeature": [], + "endOwningType": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "thisThing", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": { + "@id": "6de4760d-28f8-5ae2-8146-63a89fe58c16" + }, + "ownedRelationship": [ + { + "@id": "6de4760d-28f8-5ae2-8146-63a89fe58c16" + }, + { + "@id": "03fbb103-3063-568b-9798-7162a1cef90c" + } + ], + "ownedSpecialization": [ + { + "@id": "6de4760d-28f8-5ae2-8146-63a89fe58c16" + } + ], + "ownedSubsetting": [ + { + "@id": "6de4760d-28f8-5ae2-8146-63a89fe58c16" + } + ], + "ownedTypeFeaturing": [ + { + "@id": "03fbb103-3063-568b-9798-7162a1cef90c" + } + ], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "owningFeatureMembership": { + "@id": "5e81e92c-1411-596f-987c-880d9ea3e26a" + }, + "owningMembership": { + "@id": "5e81e92c-1411-596f-987c-880d9ea3e26a" + }, + "owningNamespace": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "owningRelationship": { + "@id": "5e81e92c-1411-596f-987c-880d9ea3e26a" + }, + "owningType": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "6de4760d-28f8-5ae2-8146-63a89fe58c16", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "6de4760d-28f8-5ae2-8146-63a89fe58c16", + "general": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "owningRelationship": null, + "owningType": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "referencingFeature": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "relatedElement": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + } + ], + "shortName": null, + "source": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + } + ], + "specific": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "subsettedFeature": { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + }, + "subsettingFeature": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "target": [ + { + "@id": "4d296856-56cf-54fe-af9d-f911a1632d55" + } + ], + "textualRepresentation": [] + }, + { + "@id": "03fbb103-3063-568b-9798-7162a1cef90c", + "@type": "TypeFeaturing", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "03fbb103-3063-568b-9798-7162a1cef90c", + "featureOfType": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "featuringType": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeatureOfType": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + }, + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "shortName": null, + "source": [ + { + "@id": "abf74499-4cb9-58d2-a324-1624000dc9ab" + } + ], + "target": [ + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "textualRepresentation": [] + }, + { + "@id": "6a94b723-e9b9-599c-acde-e82b94e950c6", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "6a94b723-e9b9-599c-acde-e82b94e950c6", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "memberElementId": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9", + "memberName": "sameThing", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "ownedMemberElementId": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9", + "ownedMemberFeature": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "ownedMemberName": "sameThing", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "owningRelationship": null, + "owningType": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "shortName": null, + "source": [ + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "target": [ + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9", + "endFeature": [], + "endOwningType": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "sameThing", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": { + "@id": "9d94f423-cc8d-5397-b293-bf12dc90130e" + }, + "ownedRelationship": [ + { + "@id": "9d94f423-cc8d-5397-b293-bf12dc90130e" + }, + { + "@id": "b1985c15-7422-5945-81d8-0279c483d126" + } + ], + "ownedSpecialization": [ + { + "@id": "9d94f423-cc8d-5397-b293-bf12dc90130e" + } + ], + "ownedSubsetting": [ + { + "@id": "9d94f423-cc8d-5397-b293-bf12dc90130e" + } + ], + "ownedTypeFeaturing": [ + { + "@id": "b1985c15-7422-5945-81d8-0279c483d126" + } + ], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "owningFeatureMembership": { + "@id": "6a94b723-e9b9-599c-acde-e82b94e950c6" + }, + "owningMembership": { + "@id": "6a94b723-e9b9-599c-acde-e82b94e950c6" + }, + "owningNamespace": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "owningRelationship": { + "@id": "6a94b723-e9b9-599c-acde-e82b94e950c6" + }, + "owningType": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "9d94f423-cc8d-5397-b293-bf12dc90130e", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "9d94f423-cc8d-5397-b293-bf12dc90130e", + "general": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "owningRelationship": null, + "owningType": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "referencingFeature": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "relatedElement": [ + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "shortName": null, + "source": [ + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "specific": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "subsettedFeature": { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + }, + "subsettingFeature": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "target": [ + { + "@id": "d1c72cc5-6726-548c-a08f-8c856be64f71" + } + ], + "textualRepresentation": [] + }, + { + "@id": "b1985c15-7422-5945-81d8-0279c483d126", + "@type": "TypeFeaturing", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "b1985c15-7422-5945-81d8-0279c483d126", + "featureOfType": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "featuringType": { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeatureOfType": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + }, + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "shortName": null, + "source": [ + { + "@id": "f77edfbc-6d87-5106-ad4f-f1d43f0af7c9" + } + ], + "target": [ + { + "@id": "3212075d-1f66-5781-aba0-bc1ae2fb36ff" + } + ], + "textualRepresentation": [] + } +] diff --git a/client/python/tests/fixtures/metamodel/bigger.sysml b/client/python/tests/fixtures/metamodel/bigger.sysml new file mode 100644 index 0000000000..a287faf647 --- /dev/null +++ b/client/python/tests/fixtures/metamodel/bigger.sysml @@ -0,0 +1,14 @@ +package Demo { + part def Base { attribute mass; } + part def Vehicle :> Base { + attribute mass2; + part wheel[4]; + port p; + ref item cargo; + action a; + constraint c { mass2 > 0 } + state s; + calc def K { in x; return y = x + 1; } + } + part v : Vehicle; +} diff --git a/client/python/tests/test_metamodel.py b/client/python/tests/test_metamodel.py new file mode 100644 index 0000000000..5977d17bfa --- /dev/null +++ b/client/python/tests/test_metamodel.py @@ -0,0 +1,99 @@ +import inspect +from types import MappingProxyType + +import pytest + +from opensysml.errors import OpenSysMLError +from opensysml.metamodel import ( + REGISTRY, + RUNTIME_MEMBERS, + Element, + ActionUsage, + Feature, + FeatureDirectionKind, + Many, + MetamodelError, + Namespace, + OccurrenceUsage, + Opt, + PartUsage, + Step, + Type, + UnknownJSONKey, + read_json, +) +from opensysml.metamodel._runtime import _ElementBase + + +def test_registry_contains_every_table_class(): + assert len(REGISTRY) == 175 + assert REGISTRY["Element"] is Element + assert issubclass(PartUsage, Feature) + assert issubclass(Feature, Type) + assert issubclass(Type, Namespace) + assert issubclass(Namespace, Element) + assert issubclass(PartUsage, Element) + assert issubclass(ActionUsage, Step) + assert issubclass(ActionUsage, OccurrenceUsage) + assert issubclass(MetamodelError, OpenSysMLError) + + +def test_aliases_and_json_key_mappings_are_consistent(): + for metaclass in REGISTRY.values(): + for key, snake in metaclass.JSON_KEYS.items(): + assert inspect.getattr_static(metaclass, key) is inspect.getattr_static( + metaclass, snake + ) + assert metaclass.json_key(metaclass.from_json_key(key)) == key + + +def test_every_descriptor_is_declared_once(): + class_owners = {} + for metaclass in REGISTRY.values(): + for value in vars(metaclass).values(): + if isinstance(value, (Many, Opt)): + class_owners.setdefault(id(value), set()).add(metaclass) + assert all(len(owners) == 1 for owners in class_owners.values()) + + +def test_runtime_members_do_not_collide_with_json_keys(): + assert isinstance(_ElementBase.JSON_KEYS, MappingProxyType) + with pytest.raises(TypeError): + _ElementBase.JSON_KEYS["unexpected"] = "unexpected" + + public = { + name + for name in set(dir(_ElementBase)) - set(dir(object)) + if not name.startswith("_") + } + assert RUNTIME_MEMBERS == public + for metaclass in REGISTRY.values(): + assert not (RUNTIME_MEMBERS & set(metaclass.JSON_KEYS)) + assert not (RUNTIME_MEMBERS & set(metaclass.JSON_KEYS.values())) + + +def test_json_key_lookup_rejects_unknown_names(): + with pytest.raises(UnknownJSONKey, match="Element.*@id"): + Element.from_json_key("@id") + with pytest.raises(UnknownJSONKey, match="Element.*bogus"): + Element.json_key("bogus") + + +def test_descriptor_metadata_and_read_only_properties(): + owned_feature = inspect.getattr_static(Type, "owned_feature") + assert isinstance(owned_feature, Many) + assert owned_feature.key == "ownedFeature" + assert owned_feature.range == "Feature" + assert owned_feature.many is True + assert owned_feature.ordered is True + assert owned_feature.derived is True + + assert Element.declared_name.derived is False + assert Type.is_abstract.range == "bool" + assert FeatureDirectionKind.IN == "in" + + element = read_json( + [{"@id": "e", "@type": "Element", "declaredName": "x"}] + )["e"] + with pytest.raises(AttributeError, match="read-only"): + element.declared_name = "y" diff --git a/client/python/tests/test_metamodel_reader.py b/client/python/tests/test_metamodel_reader.py new file mode 100644 index 0000000000..c2a9a5e202 --- /dev/null +++ b/client/python/tests/test_metamodel_reader.py @@ -0,0 +1,376 @@ +import json +import subprocess +import time + +import grpc +import pytest + +from opensysml.connection import Connection +from opensysml.conversion import ExperimentalFeatureWarning +from opensysml.metamodel import ( + Element, + FeatureDirectionKind, + LiteralInteger, + LiteralRational, + MalformedDocument, + MalformedValue, + Namespace, + NotSupplied, + PartDefinition, + PartUsage, + UnresolvedReference, + read_json, +) + + +def element(element_id="e", element_type="PartUsage", **properties): + return {"@id": element_id, "@type": element_type, **properties} + + +@pytest.fixture(scope="module") +def real_service(): + from tests.service_gate import free_port, service_binary, skip_or_fail_without_service + + binary = service_binary() + if binary is None: + skip_or_fail_without_service("no executable sysml-grpc is available; run: make build-grpc") + port = free_port() + process = subprocess.Popen( + [binary, "-port", str(port)], + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + try: + deadline = time.time() + 10 + while time.time() < deadline: + with grpc.insecure_channel(f"localhost:{port}") as channel: + try: + grpc.channel_ready_future(channel).result(timeout=0.5) + break + except grpc.FutureTimeoutError: + continue + else: + pytest.fail("sysml-grpc did not start") + yield port + finally: + process.terminate() + process.wait(timeout=10) + + +def test_reads_single_objects_bytes_and_path_inputs(tmp_path): + document = element(declaredName="engine") + graph = read_json(document) + assert graph["e"].declared_name == "engine" + assert read_json([document]).all(PartUsage)[0].json_id == "e" + encoded = json.dumps(document).encode() + assert read_json(encoded)["e"].json_type == "PartUsage" + assert read_json(bytearray(encoded))["e"].declared_name == "engine" + assert read_json(memoryview(encoded))["e"].declared_name == "engine" + + path = tmp_path / "elements.json" + path.write_text(json.dumps([document])) + assert read_json(str(path))["e"].declared_name == "engine" + assert read_json(path)["e"].declared_name == "engine" + + +def test_unwraps_data_version_and_commit_envelopes(): + first = element("first", declaredName="one") + second = element("second", declaredName="two") + data_version = [ + {"identity": {"@id": "identity-one"}, "payload": first}, + {"identity": {"@id": "identity-null"}, "payload": None}, + ] + assert read_json(data_version).all()[0].json_id == "first" + assert len(read_json(data_version)) == 1 + + commit = {"@type": "Commit", "change": [ + {"identity": {"@id": "identity-two"}, "payload": second} + ]} + assert read_json(commit)["second"].declared_name == "two" + + +def test_unwraps_standalone_data_version_envelopes(): + payload = element("p", declaredName="standalone") + envelope = {"identity": {"@id": "identity"}, "payload": payload} + assert read_json(envelope)["p"].declared_name == "standalone" + assert len(read_json({"identity": {"@id": "identity"}, "payload": None})) == 0 + + +def test_normalizes_known_types_and_preserves_written_type(): + for written in ( + "sysml:PartUsage", + "https://www.omg.org/spec/SysML#PartUsage", + "https://www.omg.org/spec/SysML/20250201/PartUsage", + ): + item = read_json(element(element_type=written))["e"] + assert isinstance(item, PartUsage) + assert item.json_type == written + + +def test_unknown_types_fall_back_or_follow_supertypes(): + fallback = read_json(element(element_type="vendor:SpecialPart"))["e"] + assert isinstance(fallback, Element) + assert fallback.json_type == "vendor:SpecialPart" + + specialized = read_json( + element(element_type="vendor:SpecialPart"), + supertypes={"vendor:SpecialPart": "Intermediate", "Intermediate": "sysml:PartUsage"}, + )["e"] + assert isinstance(specialized, PartUsage) + assert specialized.json_type == "vendor:SpecialPart" + + with pytest.raises(MalformedDocument, match="supertype cycle"): + read_json( + element(element_type="VendorTypeA"), + supertypes={ + "VendorTypeA": "VendorTypeB", + "VendorTypeB": "VendorTypeA", + }, + )["e"] + + +def test_reference_resolution_is_lazy_and_cached(): + document = [ + element("usage", partDefinition=[{"@id": "definition"}]), + element("definition", "PartDefinition", declaredName="Engine"), + ] + graph = read_json(document) + usage = graph["usage"] + assert graph["usage"] is usage + assert usage.part_definition == (graph["definition"],) + assert isinstance(usage.part_definition[0], PartDefinition) + + dangling = read_json(element(partDefinition=[{"@id": "missing"}]))["e"] + with pytest.raises(UnresolvedReference) as excinfo: + dangling.part_definition + assert excinfo.value.id == "missing" + assert excinfo.value.ref is None + assert excinfo.value.property == "PartUsage.partDefinition" + + named_reference = read_json(element(partDefinition=[{"@ref": "Engine"}]))["e"] + with pytest.raises(UnresolvedReference) as excinfo: + named_reference.part_definition + assert excinfo.value.id is None + assert excinfo.value.ref == "Engine" + + +def test_reference_ranges_require_the_declared_metaclass(): + usage = element("usage", "PartUsage", partDefinition=[{"@id": "literal"}]) + literal = element("literal", "LiteralInteger", value=1) + graph = read_json([usage, literal]) + with pytest.raises( + MalformedValue, + match=r"@id 'literal'.*json_type 'LiteralInteger'.*expected PartDefinition", + ): + graph["usage"].part_definition + + usage = element("usage", "PartUsage", partDefinition=[{"@id": "custom"}]) + custom = element("custom", "vendor:SpecialPartDefinition") + fallback = read_json([usage, custom]) + with pytest.raises(MalformedValue, match="supertypes="): + fallback["usage"].part_definition + + specialized = read_json( + [usage, custom], + supertypes={"vendor:SpecialPartDefinition": "PartDefinition"}, + ) + assert isinstance(specialized["custom"], PartDefinition) + assert specialized["usage"].part_definition == (specialized["custom"],) + + +def test_many_reference_ranges_are_checked_per_item(): + definition = element( + "definition", + "PartDefinition", + ownedFeature=[{"@id": "feature"}, {"@id": "namespace"}], + ) + feature = element("feature", "Feature") + namespace = element("namespace", "Namespace") + graph = read_json([definition, feature, namespace]) + + with pytest.raises(MalformedValue, match=r"@id 'namespace'.*expected Feature"): + graph["definition"].owned_feature + + +def test_range_checks_can_be_disabled_for_derived_references(): + document = [ + element( + "requirement", + "RequirementDefinition", + ownedInterface=[{"@id": "reference"}], + result={"@id": "requirement"}, + ), + element("reference", "ReferenceUsage"), + ] + + checked = read_json(document) + assert checked.check_ranges is True + with pytest.raises(MalformedValue): + checked["requirement"].owned_interface + with pytest.raises(MalformedValue): + checked["requirement"].result + + unchecked = read_json(document, check_ranges=False) + assert unchecked.check_ranges is False + assert unchecked["requirement"].owned_interface == (unchecked["reference"],) + assert unchecked["requirement"].result is unchecked["requirement"] + with pytest.raises(AttributeError): + unchecked.check_ranges = True + + +def test_missing_and_null_properties_preserve_cardinality(): + usage = read_json(element())["e"] + with pytest.raises(NotSupplied) as excinfo: + usage.declared_name + assert excinfo.value.property == "PartUsage.declaredName" + assert excinfo.value.key == "declaredName" + assert excinfo.value.element_id == "e" + assert excinfo.value.derived is False + + with pytest.raises(NotSupplied) as excinfo: + usage.feature + assert excinfo.value.derived is True + with pytest.raises(NotSupplied) as excinfo: + usage.json_value("feature") + assert excinfo.value.derived is True + with pytest.raises(NotSupplied): + hasattr(usage, "feature") + + feature = read_json(element(direction=None, feature=None))["e"] + assert feature.direction is None + assert feature.feature == () + assert read_json(element(feature=[]))["e"].feature == () + + +def test_enum_and_primitive_values_and_malformed_values(): + assert read_json(element(direction="in"))["e"].direction is FeatureDirectionKind.IN + assert read_json(element("t", "Type", isAbstract=True))["t"].is_abstract is True + + with pytest.raises(MalformedValue): + read_json(element(partDefinition="definition"))["e"].part_definition + with pytest.raises(MalformedValue): + read_json(element(partDefinition=[None]))["e"].part_definition + with pytest.raises(MalformedValue): + read_json(element(partDefinition=["definition"]))["e"].part_definition + with pytest.raises(MalformedValue): + read_json(element(direction=["in"]))["e"].direction + with pytest.raises(MalformedValue): + read_json(element(direction="sideways"))["e"].direction + with pytest.raises(MalformedValue): + read_json(element("t", "Type", isAbstract="true"))["t"].is_abstract + + boolean_integer = read_json(element("i", "LiteralInteger", value=True))["i"] + assert isinstance(boolean_integer, LiteralInteger) + with pytest.raises(MalformedValue): + boolean_integer.value + integer = read_json(element("valid-integer", "LiteralInteger", value=3))["valid-integer"] + assert integer.value == 3 + + rational = read_json(element("r", "LiteralRational", value=3))["r"] + assert isinstance(rational, LiteralRational) + assert rational.value == 3.0 + + +@pytest.mark.parametrize( + "value", [10**400, float("inf"), float("-inf"), float("nan")] +) +def test_rational_values_must_be_finite(value): + document = json.dumps( + element("r", "LiteralRational", value=value), allow_nan=True + ).encode() + rational = read_json(document)["r"] + + with pytest.raises(MalformedValue, match="finite"): + rational.value + + +@pytest.mark.parametrize( + "document", + [ + b"null", + b"42", + b'"text"', + b"{", + [{"@type": "Element"}], + [{"@id": "missing-type"}], + [element(element_id=3)], + [element(element_type=3)], + [element(), element()], + ], +) +def test_malformed_documents_fail_eagerly(document): + with pytest.raises(MalformedDocument): + read_json(document) + + +def test_graph_collection_behavior_and_roots(): + namespace = element("root", "Namespace") + child = element("child", "Namespace") + reference = element("owner", "Element", ownedRelationship=[{"@id": "child"}]) + graph = read_json([namespace, child, reference]) + + assert len(graph) == 3 + assert [item.json_id for item in graph] == ["root", "child", "owner"] + assert "root" in graph + assert "absent" not in graph + assert graph.get("absent") is None + assert graph.get("absent", "fallback") == "fallback" + with pytest.raises(KeyError): + graph["absent"] + assert graph.all(Namespace) == (graph["root"], graph["child"]) + assert graph.roots() == (graph["root"],) + assert graph.roots() is graph.roots() + + +@pytest.mark.parametrize("key", ["owner", "owningNamespace"]) +@pytest.mark.parametrize("owner_id", ["root", "outside"]) +def test_roots_excludes_namespaces_with_owner_metadata(key, owner_id): + root = element("root", "Namespace") + nested = element("nested", "Namespace", **{key: {"@id": owner_id}}) + graph = read_json([root, nested]) + + assert graph.roots() == (graph["root"],) + + +def test_elements_compare_by_graph_identity_and_id(): + first_graph = read_json(element(declaredName="engine")) + second_graph = read_json(element(declaredName="engine")) + first = first_graph["e"] + same = first_graph["e"] + other = second_graph["e"] + + assert first == same + assert hash(first) == hash(same) + assert first != other + assert len({first, same, other}) == 2 + + +@pytest.mark.integration +def test_reads_api_json_from_the_open_sysml_service(real_service): + source = """package ReaderDemo { + part def Engine { + attribute power : Real = 300.0; + } + part engine : Engine; +} +""" + with Connection(port=real_service, auto_start=False) as connection: + model = connection.load_from_content(source) + with pytest.warns(ExperimentalFeatureWarning): + exported = model.to_api_json() + + graph = read_json(json.loads(str(exported))) + usage = next(part for part in graph.all(PartUsage) if part.declared_name == "engine") + assert usage.declared_name == "engine" + for name in ("feature", "inherited_feature", "definition"): + with pytest.raises(NotSupplied) as excinfo: + getattr(usage, name) + assert excinfo.value.derived is True + + definition = next( + item for item in graph.all(PartDefinition) if item.declared_name == "Engine" + ) + assert usage.type == (definition,) + assert definition.owned_feature + assert all(isinstance(feature, Element) for feature in definition.owned_feature) + assert all(feature in graph.all() for feature in definition.owned_feature) diff --git a/client/python/tests/test_metamodel_toolkit.py b/client/python/tests/test_metamodel_toolkit.py new file mode 100644 index 0000000000..bb589e325b --- /dev/null +++ b/client/python/tests/test_metamodel_toolkit.py @@ -0,0 +1,65 @@ +import json +from pathlib import Path + +import pytest + +from opensysml.metamodel import ( + Feature, + MultiplicityRange, + Namespace, + NotSupplied, + PartDefinition, + PartUsage, + Type, + read_json, +) + + +FIXTURE = Path(__file__).parent / "fixtures" / "metamodel" / "bigger.full.json" + + +def test_reads_toolkit_full_json_fixture(): + document = json.loads(FIXTURE.read_text()) + graph = read_json(FIXTURE) + assert len(graph) == 87 + + parts = graph.all(PartUsage) + assert [part.declared_name for part in parts] == ["wheel", "v"] + assert all(isinstance(part, Feature) for part in parts) + + vehicle = next(item for item in graph.all(PartDefinition) if item.declared_name == "Vehicle") + assert isinstance(vehicle, Type) + raw_vehicle = next( + raw + for raw in document + if raw.get("@type") == "PartDefinition" and raw.get("declaredName") == "Vehicle" + ) + assert vehicle.owned_feature == tuple( + graph[element["@id"]] for element in raw_vehicle["ownedFeature"] + ) + assert [feature.declared_name for feature in vehicle.owned_feature] == [ + "mass2", "wheel", "p", "cargo", "a", "c", "s" + ] + assert len(vehicle.feature) == 7 + assert all(isinstance(feature, Feature) for feature in vehicle.feature) + assert all(feature.json_id in graph for feature in vehicle.feature) + + bounded_range = next( + item + for item in graph.all(MultiplicityRange) + if any(raw.get("@id") == item.json_id and "bound" in raw for raw in document) + ) + assert isinstance(bounded_range.bound, tuple) + + usage = next(part for part in parts if part.declared_name == "v") + assert usage.type == (vehicle,) + assert usage.type[0] is graph[vehicle.json_id] + assert len(graph.roots()) == 1 + assert isinstance(graph.roots()[0], Namespace) + + missing_name = dict(raw_vehicle) + del missing_name["qualifiedName"] + incomplete = read_json([missing_name])[missing_name["@id"]] + with pytest.raises(NotSupplied) as excinfo: + incomplete.qualified_name + assert excinfo.value.derived is True diff --git a/client/python/tests/test_metamodel_typing.py b/client/python/tests/test_metamodel_typing.py new file mode 100644 index 0000000000..40a523c2f2 --- /dev/null +++ b/client/python/tests/test_metamodel_typing.py @@ -0,0 +1,57 @@ +import importlib.util +import os +import shutil +import subprocess +import sys +from pathlib import Path + +import pytest + + +PYTHON_ROOT = Path(__file__).resolve().parents[1] +TYPECHECK_SOURCE = Path(__file__).parent / "typecheck" / "metamodel_usage.py" +TYPECHECK_DIR = TYPECHECK_SOURCE.parent + + +def test_metamodel_types_with_mypy_and_pyright(): + missing = [] + if importlib.util.find_spec("mypy") is None: + missing.append("mypy") + if shutil.which("pyright") is None: + missing.append("pyright") + if missing: + message = "missing type checker(s): " + ", ".join(missing) + if os.environ.get("OPENSYSML_REQUIRE_TYPECHECKERS", "").strip().lower() not in ( + "", + "0", + "false", + "no", + ): + pytest.fail(message) + pytest.skip(message) + + package = PYTHON_ROOT / "opensysml" / "metamodel" + mypy = subprocess.run( + [ + sys.executable, + "-m", + "mypy", + "--strict", + "--config-file", + str(TYPECHECK_DIR / "mypy.ini"), + str(TYPECHECK_SOURCE), + str(package), + ], + cwd=PYTHON_ROOT, + text=True, + capture_output=True, + ) + assert mypy.returncode == 0, mypy.stdout + mypy.stderr + + pyright = subprocess.run( + ["pyright", "-p", str(TYPECHECK_DIR)], + cwd=PYTHON_ROOT, + text=True, + capture_output=True, + ) + assert pyright.returncode == 0, pyright.stdout + pyright.stderr diff --git a/client/python/tests/typecheck/metamodel_usage.py b/client/python/tests/typecheck/metamodel_usage.py new file mode 100644 index 0000000000..4a4099a436 --- /dev/null +++ b/client/python/tests/typecheck/metamodel_usage.py @@ -0,0 +1,43 @@ +import builtins + +from opensysml.metamodel import ( + Element, + Feature, + FeatureDirectionKind, + PartDefinition, + PartUsage, + REGISTRY, + Type, + read_json, +) + + +def check_usage() -> None: + graph = read_json([{"@id": "part", "@type": "PartUsage"}]) + parts: tuple[PartUsage, ...] = graph.all(PartUsage) + part = parts[0] + name: str | None = part.declared_name + features: tuple[Feature, ...] = part.feature + camel_alias: tuple[Feature, ...] = part.ownedFeature + part_types: tuple[Type, ...] = part.type + abstract: bool | None = part.is_abstract + direction: FeatureDirectionKind | None = part.direction + part_class: builtins.type[Element] = REGISTRY["PartUsage"] + element: Element = graph.all()[0] + if isinstance(element, PartUsage): + narrowed_name: str | None = element.declared_name + assert narrowed_name == name + assert features == part.feature + assert camel_alias == part.owned_feature + assert part_types == part.type + assert abstract is None + assert direction is None + assert part_class is PartUsage + + misspelled: object = part.ownedFeatur # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue, reportUnknownMemberType, reportUnknownVariableType] + wrong_parts: tuple[PartDefinition, ...] = graph.all(PartUsage) # type: ignore[arg-type] # pyright: ignore[reportAssignmentType] + part.declared_name = 1 # type: ignore[assignment] # pyright: ignore[reportAttributeAccessIssue] + wrong_owned: list[Feature] = part.owned_feature # type: ignore[assignment] # pyright: ignore[reportAssignmentType] + assert misspelled + assert wrong_parts + assert wrong_owned diff --git a/client/python/tests/typecheck/mypy.ini b/client/python/tests/typecheck/mypy.ini new file mode 100644 index 0000000000..73c273750f --- /dev/null +++ b/client/python/tests/typecheck/mypy.ini @@ -0,0 +1,7 @@ +[mypy] +python_version = 3.10 +warn_unused_ignores = True +follow_imports = silent + +[mypy-opensysml.proto.*] +disable_error_code = type-arg, no-untyped-def diff --git a/client/python/tests/typecheck/pyrightconfig.json b/client/python/tests/typecheck/pyrightconfig.json new file mode 100644 index 0000000000..99ddf452d2 --- /dev/null +++ b/client/python/tests/typecheck/pyrightconfig.json @@ -0,0 +1,13 @@ +{ + "include": [ + "metamodel_usage.py", + "../../opensysml/metamodel" + ], + "extraPaths": [ + "../.." + ], + "pythonVersion": "3.10", + "typeCheckingMode": "strict", + "reportUnnecessaryTypeIgnoreComment": true, + "enableTypeIgnoreComments": false +} diff --git a/docs/clients/python/index.md b/docs/clients/python/index.md index fc17970b6c..187b03cccf 100644 --- a/docs/clients/python/index.md +++ b/docs/clients/python/index.md @@ -107,4 +107,5 @@ or install `sysml-grpc` on `$PATH`. - [Errors](errors.md) - [The service](service.md) - [Typed classes](typed-classes.md) +- [Metamodel classes and JSON](metamodel.md) - [Python API reference](../../reference/python-api.md) diff --git a/docs/clients/python/metamodel.md b/docs/clients/python/metamodel.md new file mode 100644 index 0000000000..de0c939a83 --- /dev/null +++ b/docs/clients/python/metamodel.md @@ -0,0 +1,72 @@ +# Metamodel classes and JSON + +`opensysml.metamodel` holds one generated class per SysML/KerML metaclass +(`Element`, `Namespace`, `Feature`, `PartUsage`, ...), each with one read-only +property per metamodel property. `opensysml.read_json` builds those objects +from a JSON export in pure Python: it needs no `sysml-grpc` service, never +converts to notation and never writes back. + +This is not the same as [typed classes](typed-classes.md): +`opensysml.generate` writes classes for the definitions in *your* model +(`Vehicle`, `Engine`) over service-backed instances, while the metamodel +classes describe the language's own elements and are the same for every model. + +```python +import opensysml +from opensysml.metamodel import Feature, PartUsage + +g = opensysml.read_json("vehicle.full.json") # sysml-toolkit full-json + +for p in g.all(PartUsage): + print(p.qualifiedName, [t.name for t in p.type], len(p.ownedFeature)) + assert isinstance(p, Feature) # follows the spec hierarchy +``` + +The classes follow the metamodel's inheritance, so `graph.all(Feature)` also +returns every `PartUsage`. `graph[id]` looks an element up by `@id`, and +`graph.roots()` returns the namespaces the document records no owner for. References are +resolved when read, and many-valued properties return tuples. + +## Names + +Each property's primary name is `snake_case` (`owned_feature`, `is_abstract`); +the spec's `camelCase` name (`ownedFeature`, `isAbstract`) is an alias for the +same descriptor, so both spellings behave identically and type-check. A name +that would be a Python keyword gets a trailing `_`. `PartUsage.from_json_key("partDefinition")` +and `PartUsage.json_key("part_definition")` convert between the two. The +package ships `py.typed`, so mypy and pyright see every property's type. + +## Inputs + +`read_json` accepts a file path (a `str` is always a path, never JSON text), +bytes, a single element object, or a list of element objects, with `@id`, +`@type` and `{"@id": ...}` references. It also unwraps SysML v2 API DataVersion +(`identity`/`payload`) and Commit (`change`) envelopes and `sysml:`-prefixed or +IRI types. An `@type` the metamodel does not know is read as its nearest known +ancestor when you pass `supertypes={"MyType": "PartUsage", ...}`, otherwise as +`Element`; `element.json_type` keeps the written name. + +## Missing, empty and dangling values + +A property the JSON does not carry raises `NotSupplied` (its `.derived` says +whether the property is computed). It never reads as `None` or `()` instead: +only an explicit `null` or `[]` in the JSON means empty. A reference to an `@id` +the document does not contain raises `UnresolvedReference` when read. A reference +to an element of the wrong metaclass raises `MalformedValue`. Some exports write +derived values outside their range (sysml-toolkit full-json sets a requirement +definition's `result` to the definition itself, for example); +`read_json(..., check_ranges=False)` returns such elements as written instead. + +OpenSysML's `api-json` export carries the owned properties it writes plus some derived ones +(`ownedFeature`, `owner`, `qualifiedName`, `ownedMember`, ...). It carries no `feature`, +`inheritedFeature` or `definition`, and `type` only on some usages, so those reads raise +`NotSupplied` with `derived=True` until the engine serves derived properties. The export also +writes no `null` and no `[]`: an unset owned property, such as an unnamed element's +`declaredName`, is absent and raises `NotSupplied` too. sysml-toolkit `full-json` carries derived +properties as well. A reference to an element the document does not include, such as a +standard-library element, raises `UnresolvedReference` when read. +Providing engine-computed derived properties, implementing metamodel operations, and loading JSON +into the OpenSysML engine are separate follow-up work. + +See the [Python API reference](../../reference/python-api.md#metamodel-classes-and-the-json-reader) +for the full error table. diff --git a/docs/clients/python/typed-classes.md b/docs/clients/python/typed-classes.md index 26aaf810f1..ef2b411889 100644 --- a/docs/clients/python/typed-classes.md +++ b/docs/clients/python/typed-classes.md @@ -5,6 +5,9 @@ checker cannot reject `inst.mas`. `opensysml.generate` emits a Python class for each SysML definition so applications can add static checking around the same runtime instances. +For classes describing the SysML metamodel itself, read from a JSON export, see +[Metamodel classes and JSON](metamodel.md). + ```bash python -m opensysml.generate model.sysml -o model_types.py opensysml-generate model.sysml -o model_types.py diff --git a/docs/guide/09-clients.md b/docs/guide/09-clients.md index e21c308197..ee291ff2e7 100644 --- a/docs/guide/09-clients.md +++ b/docs/guide/09-clients.md @@ -221,6 +221,8 @@ The [client index](../clients.md) links to the Go overview and walkthrough. The The [Python client guide](../clients/python/index.md) is split by task, from models and diagnostics through verification, editing, queries and service setup. See also the [Python API reference](../reference/python-api.md). +[Metamodel classes and JSON](../clients/python/metamodel.md) reads a JSON export into generated +SysML metamodel classes without a service. ## From Node or a browser diff --git a/docs/project/roadmap.md b/docs/project/roadmap.md index 647ba0fa68..7081dca6f8 100644 --- a/docs/project/roadmap.md +++ b/docs/project/roadmap.md @@ -718,11 +718,13 @@ the inventory in `tests/export/testdata/ontology-known-violations.txt`. The `typ `function` and `targetFeature` keys stay listed for the fixtures' unresolvable names and body parameters above; the parameters go when D1/D2 make expression bodies elements of the graph. -The abstract-metaclass half is not mechanizable from the ontology: `SysML.owl` records no ecore -abstractness (see D8), so every metaclass the encoder writes (`kinds.go` and the constants in -`rdf_out.go`/`rdf_expr.go`) was checked by hand against the abstract classes of the pilot's -`SysML.ecore` and `kerml.ecore` — `ConnectorAsUsage`, `ControlNode`, `Element`, `Expose`, -`Import`, `InstantiationExpression`, `LoopActionUsage`, `Relationship`. Two were written: +The abstract-metaclass half was checked by hand while the table came from `SysML.owl`, which +records no ecore abstractness: every metaclass the encoder writes (`kinds.go` and the constants in +`rdf_out.go`/`rdf_expr.go`) against the abstract classes of the pilot's `SysML.ecore` and +`kerml.ecore` — `ConnectorAsUsage`, `ControlNode`, `Element`, `Expose`, `Import`, +`InstantiationExpression`, `LoopActionUsage`, `Relationship`. Generated from the ecore (D8), the +table now records them, and the same gate reports a subject typed by one as `abstract-class`; no +golden graph has one. Two were written: `Import`, now `NamespaceImport` / `MembershipImport` and, for an `expose`, `NamespaceExpose` / `MembershipExpose` in place of an `sysx:isExpose` flag, and `ConnectorAsUsage` for a KerML `connector`, now `Connector`. The decoder still accepts both abstract classes from older graphs. @@ -733,7 +735,9 @@ still delivers every `type`, `referent` and `targetFeature` of its fixture. [`Open-MBEE/sysmlv2-rdf-ontology`](https://github.com/Open-MBEE/sysmlv2-rdf-ontology) renders the OMG metamodel (version 202407, from `SysML.ecore`) as OML and OWL: `SysML.owl`, 172 classes, 348 -object properties, 63 datatype properties, with `rdfs:domain`/`rdfs:range` on each. It uses the +object properties, 63 datatype properties, with `rdfs:domain`/`rdfs:range` on each, and has not +been regenerated since. The current metamodel, version 20250201 as the pinned pilot's `SysML.ecore` +declares it, has 175 classes, 351 object properties and 64 datatype properties. It uses the *same* namespace we do and its class IRIs are the plain metaclass names we already emit; the difference is the properties, each qualified by the metaclass that defines it (`sysml:Element_declaredName`, `sysml:Element_owner` with range `OwningMembership`), and a @@ -747,9 +751,12 @@ structural decisions (`internal/translate/export/rdf_out.go`), so the profile is layer: property name → defining metaclass. **Done:** the table and the gate. `internal/translate/rdf/ontology` holds the term table generated -from `SysML.owl` by `tools/gen/ontology` from a local checkout (version `202407`, -upstream commit in the generated header): 411 properties spanning only **336 distinct unqualified -names — 59 names are declared by more than one metaclass** (`type`, `value`, `source`, `target`, +by `tools/gen/ontology` from the pilot's `SysML.ecore` at the release `scripts/pilot-pin.sh` pins +(version `20250201`, pilot tag and commit in the generated header), naming each property by the +OWL rendering's `_` IRI and recording its multiplicity, ordering, derivation, +redefinitions, subsettings and opposite; `make ontology-table-check` keeps it equal to the pin in +CI. It holds 415 properties spanning only **342 distinct unqualified +names — 58 names are declared by more than one metaclass** (`type`, `value`, `source`, `target`, …), so the unqualified convention is genuinely lossy in the other direction and a profile encoder has to pick by the subject's metaclass (`LookupProperty` returns every declaration; `AmbiguousNames` reports the set). The gate is `TestGoldenGraphsMatchOntology`, whose inventory is @@ -757,8 +764,8 @@ also the profile's work list, sorted into five causes: properties the metamodel relationship or membership element that we collapse into the element (`value` → `FeatureValue`, the multiplicity bounds → `MultiplicityRange`, `isNegated` → `Invariant`, a transition's ends → `Connector`) — the same collapse D3.3 undid for ownership and D1/D2 will undo for expressions and -ends; names as literals (D7); metaclass names the 202407 rendering does not have (`FlowUsage`, -which it calls `FlowConnectionUsage`, and `TerminateActionUsage`); the metaclasses of our own +ends; names as literals (D7); metaclass names the metamodel does not have (`ClassUsage`, +`IndividualDefinition`, `IndividualUsage`); the metaclasses of our own `sysx:` namespace; and the properties we write into the SysML namespace that no metaclass declares, each either a relationship the metamodel reifies as an element (`specializes`, `subsets`, `redefines`, `references`, `aliasedElement`, `via`) or a notation flag with no diff --git a/docs/project/spec-compliance.md b/docs/project/spec-compliance.md index 9d5a16843b..8a9e1488ce 100644 --- a/docs/project/spec-compliance.md +++ b/docs/project/spec-compliance.md @@ -2735,7 +2735,7 @@ a whole model or that its vocabulary is settled — see | Ownership as the abstract syntax states it: `sysml:owner` and `sysml:owningRelatedElement` as element references, and a materialized `OwningMembership` — or `FeatureMembership` where a type owns a feature — between owner and member, each with its own IRI, `sysml:elementId` and member/owner wiring | `export/rdf_out.go` `owningMembership`/`relationshipOwnership`, `rdf/ids.go` `OwningMembershipID` (the member's id plus `_om`, which no element id can be) | `export/ownership_graph_test.go:TestEveryElementCarriesItsElementID`, `:TestOnlyTheOutermostElementIsARoot`, `:TestMembersAreReachedThroughTheirMembership`, `:TestAFeatureIsOwnedThroughAFeatureMembership`, `:TestARelationshipOwnsItsMemberDirectly`, `:TestVisibilityIsStatedByTheMembership`, `:TestOwnershipComesBackFromTheMembershipsAlone`, `:TestWithoutAnyOwnershipPropertyTheTreeFlattens`, `:TestCompactOwnershipGraphStillConverts`, `:TestMembershipWithoutItsEndsIsReported` | ✅ Faithful for containment — one root per document, and the tree comes back from the memberships alone with `sysx:sourceText` and `sysml:owningNamespace` stripped. The compact `sysml:owningNamespace` shape earlier releases wrote is still written and still read; a membership missing an end is a typed error naming `sysml:memberElement`. Not claimed: a graph read back through a live Flexo API | | Expression node identity: an id in `[a-zA-Z0-9_-]+` and `sysml:elementId`, so a node is addressable by id like an element | `rdf/ids.go` `ExpressionNodeID` (the owner's id, `_p`, and the encoded position, which no element or membership id can be), `rdf/vocab.go` `ExpressionIRI`, `export/rdf_expr.go` `expressionNode` | `rdf/ids_test.go:TestExpressionNodeIDRoundTripsAndCannotCollide`, `export/export_test.go:TestFixtureElementIDsRoundTrip`, `export/w6g4_rdf_expr_test.go:TestExpressionIdentityIsPerPosition`, `:TestExpressionTreesKeepTheRoundTripExact` | ✅ Faithful for addressing — the id is deterministic, reversible and accepted where an element id is; the `.` an earlier id held was refused by `requireValidId` before the store was read. A node is still not a model element: no `sysml:qualifiedName`, no ownership, and it is reached only from the position holding it | | Reference-valued properties as element references, as the API defines them: `sysml:type`, `importedNamespace`, `importedMembership` (the imported element's owning membership, KerML §8.3.2.5 `MembershipImport::importedMembership`), `sourceFeature`/`targetFeature`, `referent`, `function`, and every declaration-head relationship link the element the name resolves to — an element of the graph by its id, a standard library element by its normative id whether or not the library is in the graph — and stay a literal only for a name that resolves to nothing the model declares or a body parameter, which is no element | `export/rdf_out.go` `reference`, `importedMembership`; `export/rdf_identity.go` `subjectForNode` (normative ids through `identity.LibraryCatalog`); `export/names.go` resolver-checked shortest spelling; `export/rdf_in.go` `referenceName`, `libraryElement` (reads an IRI or a legacy literal) | `tests/export/reference_iris_test.go` `TestReferencePropertiesLinkElements` (a library type, a current-document type, an inherited `start`, a feature chain, a membership import's owning membership, a metadata definition by short name, an unresolvable name kept as a literal), `TestLegacyReferenceGraphsStillRead`; `tests/export/ontology_gate_test.go` `TestGoldenGraphsMatchOntology` (the `literal-for-object-property` inventory shrank to the fixtures' unresolvable names) | ✅ Faithful (a graph from a release that wrote the name as a literal reads back and gains the links on its next hop) | -| Every metaclass written is concrete in the metamodel, as every element the SysML v2 API returns is: an import is `sysml:NamespaceImport` or `sysml:MembershipImport`, never abstract `sysml:Import`; a KerML `connector` is `sysml:Connector`, never abstract `sysml:ConnectorAsUsage`; and no other abstract class of the pilot's `SysML.ecore`/`kerml.ecore` (`ControlNode`, `Element`, `Expose`, `InstantiationExpression`, `LoopActionUsage`, `Relationship`) is written | `export/rdf_out.go` `encodeMember` (`mNamespaceImport`/`mMembershipImport`); `export/kinds.go` `usageMetaclass` (`Connector`), `legacyConnectorAsUsage`; `export/rdf_in.go` `declarationHead` (accepts `sysml:Import` and `sysml:ConnectorAsUsage` from older graphs) | `tests/export/reference_iris_test.go` `TestReferencePropertiesLinkElements`, `TestLegacyReferenceGraphsStillRead` (abstract `sysml:Import`), `TestLegacyConnectorAsUsageStillReads`; golden `imports.golden.ttl` | ✅ Faithful (audited by hand against the ecore models' abstract classes, which the pinned `SysML.owl` does not record) | +| Every metaclass written is concrete in the metamodel, as every element the SysML v2 API returns is: an import is `sysml:NamespaceImport` or `sysml:MembershipImport`, never abstract `sysml:Import`; a KerML `connector` is `sysml:Connector`, never abstract `sysml:ConnectorAsUsage`; and no other abstract class of the pilot's `SysML.ecore`/`kerml.ecore` (`ControlNode`, `Element`, `Expose`, `InstantiationExpression`, `LoopActionUsage`, `Relationship`) is written | `export/rdf_out.go` `encodeMember` (`mNamespaceImport`/`mMembershipImport`); `export/kinds.go` `usageMetaclass` (`Connector`), `legacyConnectorAsUsage`; `export/rdf_in.go` `declarationHead` (accepts `sysml:Import` and `sysml:ConnectorAsUsage` from older graphs) | `tests/export/reference_iris_test.go` `TestReferencePropertiesLinkElements`, `TestLegacyReferenceGraphsStillRead` (abstract `sysml:Import`), `TestLegacyConnectorAsUsageStillReads`; golden `imports.golden.ttl` | ✅ Faithful (`TestGoldenGraphsMatchOntology` reports a subject typed by a metaclass the pinned `SysML.ecore` declares abstract) | | Ownership cycle in an input graph | refused: every element's `owningNamespace` chain must reach a root, or no root owns the element and printing would emit an empty document | `export_test.go:TestOwnershipCycleIsUnsupported` | ⛔ Rejected rather than emitting an empty file (deliberate). Ownership in the abstract syntax is a tree — an element has at most one owning relationship, and the graph is what a notation document nests — so a cycle is not an unrepresentable model but an inconsistent graph. The alternative, writing the elements a root does reach, would silently drop the cycle's members; the refusal names the elements in it | | Lexical `//` and `/* */` trivia across the RDF hop | no element owns trivia; `doc`/`comment` are declarations and do convert | `export_test.go:TestCommentsThroughRDF` | ⛔ Not carried through `.ttl` (a direct `.sysml` save keeps it). Trivia belongs to no element in the abstract syntax, so there is no subject to hang it on; carrying it as a per-element `sysx:` blob would make the graph a source archive rather than a model. The surfaces say so: `sysml -convert` and `%save` print the experimental note, and the guide points at the notation save for round trips that must keep comments | | Blank nodes, RDF collections, bare literal shorthands | rejected by `rdf.ParseTurtle` | `rdf_test.go:TestParseTurtleRejects` | ⛔ Not supported (deliberate; see [the mapping](../reference/rdf-mapping.md)). This is a subset of Turtle, not all of it: an element of this graph is addressed by an IRI derived from its qualified name, and a blank node has no such name, so a blank-node subject could not be read back as an element or written twice to the same address. Collections and bare literal shorthands are unused by anything this mapping writes. A parse error names the line rather than dropping the statement, so a foreign graph using them fails loudly | diff --git a/docs/reference/python-api.md b/docs/reference/python-api.md index 77d784db39..6b8895314c 100644 --- a/docs/reference/python-api.md +++ b/docs/reference/python-api.md @@ -48,6 +48,10 @@ connecting to models. options: heading_level: 3 +::: opensysml.read_json + options: + heading_level: 3 + ::: opensysml.parse_sources options: heading_level: 3 @@ -80,6 +84,59 @@ connecting to models. options: heading_level: 3 +## Metamodel classes and the JSON reader + +`opensysml.generate` creates classes for definitions in a user's SysML model. The separate +`opensysml.metamodel` package contains generated classes for the SysML metamodel itself. Use +`opensysml.read_json` to wrap an exported JSON document without starting a service: + +```python +import opensysml +from opensysml.metamodel import PartDefinition, PartUsage + +graph = opensysml.read_json("vehicle.json") +vehicle = next( + definition for definition in graph.all(PartDefinition) + if definition.declared_name == "Vehicle" +) +print([feature.declared_name for feature in vehicle.owned_feature]) +for part in graph.all(PartUsage): + print(part.declared_name) +``` + +Elements use the metaclass inheritance hierarchy, so `isinstance(part, Feature)` works. Property +names use `snake_case` primarily (`owned_feature`) and expose their SysML `camelCase` spelling as +an alias (`ownedFeature`) to the same descriptor. `PartUsage.from_json_key("partDefinition")` +returns the primary Python name, and `PartUsage.json_key("part_definition")` returns the JSON key. +Strings passed to `read_json` are file paths, not JSON text; bytes, mappings, and sequences of +element mappings are also accepted. The reader understands DataVersion and Commit envelopes. +Reference targets are checked against their declared metaclass ranges by default; pass +`check_ranges=False` to return out-of-range targets as written. + +Missing keys raise `NotSupplied`, including absent multi-valued properties. Dangling `@id` and +unresolved `@ref` values raise `UnresolvedReference` when accessed. Invalid document structure +raises `MalformedDocument`, and a value outside its declared type raises `MalformedValue`. +These exceptions share `MetamodelError`, a subclass of `opensysml.errors.OpenSysMLError`: + +| Error | Raised when | +| --- | --- | +| `NotSupplied` | A declared JSON key is absent; `.derived` identifies computed properties. | +| `UnresolvedReference` | A reference's `@id` is absent from the graph or its `@ref` cannot be resolved. | +| `MalformedValue` | A property value has the wrong primitive, enum, array, or reference shape, or (when range checks are enabled) a reference targets the wrong metaclass. | +| `MalformedDocument` | The input is not an element object/array, or has missing/duplicate IDs or types. | +| `UnknownJSONKey` | A JSON key is not declared for the selected metaclass. | + +OpenSysML's `api-json` export carries the owned properties it writes plus some derived ones +(`ownedFeature`, `owner`, `qualifiedName`, `ownedMember`, ...). It carries no `feature`, +`inheritedFeature` or `definition`, and `type` only on some usages, so those reads raise +`NotSupplied` with `derived=True` until the engine serves derived properties. The export also +writes no `null` and no `[]`: an unset owned property, such as an unnamed element's +`declaredName`, is absent and raises `NotSupplied` too. sysml-toolkit `full-json` carries derived +properties as well. A reference to an element the document does not include, such as a +standard-library element, raises `UnresolvedReference` when read. +Providing engine-computed derived properties, implementing metamodel operations, and loading JSON +into the OpenSysML engine are separate follow-up work. + ## opensysml.connection Connections own or reach a service, and resolve their address and release. diff --git a/docs/reference/rdf-mapping.md b/docs/reference/rdf-mapping.md index e51300ab29..14b2f6b528 100644 --- a/docs/reference/rdf-mapping.md +++ b/docs/reference/rdf-mapping.md @@ -378,9 +378,12 @@ triples come); a set of classes with no such member is refused, naming the subje an element a relationship owns, whose owner is no namespace), kept alongside `sysml:owner` as the compact spelling earlier releases wrote - `sysml:visibility`, `sysml:direction` +- `sysml:isUnique` `false` for `nonunique` (`Feature::isUnique`, true when + absent), the one flag written false. The `sysml:isNonunique` earlier releases + wrote, which the 20250201 metamodel no longer declares, still reads. - Feature flags, written only when true, so an absent flag reads as false: `isAbstract`, `isVariation`, `isVariant`, `isReference`, `isComposite`, `isDerived`, - `isOrdered`, `isNonunique`, `isEnd`, `isConstant`, `isIndividual`, `isPortion`, + `isOrdered`, `isEnd`, `isConstant`, `isIndividual`, `isPortion`, `isConjugated`, `isAll`, `isAccept`, `isResult`, and `isEvent` for an `event` modifier on a usage whose metaclass is not itself `sysml:EventOccurrenceUsage`. A flag the two grammars spell differently is written back in the grammar of @@ -562,7 +565,7 @@ The `sysx:` properties: | the behavioral properties | `sysx:guard`, `sysx:expression`, `sysx:payload`, … — the parts of a behavioral node the vocabulary has no predicate for, listed under [Behavior](#behavior). | For expressions and end-binding heads, the encoder still emits these `sysx:` -terms. They carry notation or ordering facts for which the 202407 metamodel has +terms. They carry notation or ordering facts for which the metamodel has no property; they are annotations, not replacements for the standard shape: | Terms | Why the annotation remains | @@ -626,6 +629,14 @@ from: - `sysx:ActionExecutionNode` — `action a { x + 1 }`, an action node performing an inline expression, which no SysML v2 production spells. +A type owns a `FlowUsage`, `SuccessionFlowUsage`, `FlowEnd`, `PayloadFeature`, +`TerminateActionUsage` or `ConstructorExpression`, `IndexExpression` or +`InstantiationExpression` through a `sysml:FeatureMembership`, listed in its +`sysml:ownedFeature`, as it owns any feature. Releases whose metamodel table +predated these metaclasses (version 202407) owned them through a plain +`sysml:OwningMembership`; in a SysML graph, which has no `member` keyword, that +shape still reads back as the same feature. + Reading, the metaclasses earlier releases wrote for the standard constructs above — `sysx:Alias`, `sysx:FilterMember`, `sysx:MultiplicityDeclaration`, `sysx:ConstraintMember`, `sysx:AssumeMember`, `sysx:RequireMember`, @@ -1509,8 +1520,8 @@ A flow's `of` clause is a `sysml:PayloadFeature` the flow owns through a is that feature, named `p`, so `m.p` reaches it; `of T` and `of T[1]` state only its `FeatureTyping` and multiplicity, and the feature takes the flow's next position as its name (`…::@0` in a flow with no body members). Read back, the -feature is written after `of`, not in the flow's body. 202407 names the -metaclass `ItemFeature`. A graph written before this states the payload as the +feature is written after `of`, not in the flow's body. The 202407 metamodel +named the metaclass `ItemFeature`. A graph written before this states the payload as the expression `sysx:payload` and still reads back with it; a flow stating both, or a `PayloadFeature` owned by anything but a flow, is refused. diff --git a/internal/translate/export/end_forms.go b/internal/translate/export/end_forms.go index 2de46efb5a..2021744fe6 100644 --- a/internal/translate/export/end_forms.go +++ b/internal/translate/export/end_forms.go @@ -425,7 +425,7 @@ func (d *decoder) payloadText(el *element) (string, error) { if d.boolOf(payload, rdf.SysML+"isOrdered") { flags += " ordered" } - if d.boolOf(payload, rdf.SysML+"isNonunique") { + if d.nonunique(payload) { flags += " nonunique" } words := d.identWords(payload) diff --git a/internal/translate/export/rdf_expr.go b/internal/translate/export/rdf_expr.go index 8e5c86bae3..11d1ac1ef9 100644 --- a/internal/translate/export/rdf_expr.go +++ b/internal/translate/export/rdf_expr.go @@ -55,7 +55,7 @@ const ( ) // Properties this mapping adds: argument order, which RDF does not carry, and -// parts the 202407 metamodel rendering has no property for. +// parts the metamodel has no property for. const ( xArgumentIndex = "argumentIndex" xArgumentName = "argumentName" diff --git a/internal/translate/export/rdf_in.go b/internal/translate/export/rdf_in.go index baaf34ea57..6086236d30 100644 --- a/internal/translate/export/rdf_in.go +++ b/internal/translate/export/rdf_in.go @@ -302,7 +302,7 @@ func checkTypes(graph *rdf.Graph) (map[rdf.Term]string, error) { } metaclasses := make(map[rdf.Term]string, len(stated)) for _, subject := range subjects { - class, ok := mostSpecific(stated[subject]) + class, ok := ontology.MostSpecific(stated[subject]) if !ok { return nil, &UnsupportedError{ What: fmt.Sprintf("the subject <%s>", subject.Value), @@ -314,31 +314,6 @@ func checkTypes(graph *rdf.Graph) (map[rdf.Term]string, error) { return metaclasses, nil } -// mostSpecific picks the class among those stated that every other is a -// superclass of, reporting false when there is none. -func mostSpecific(classes []string) (string, bool) { - for _, class := range classes { - specific := true - for _, other := range classes { - if !subclassOf(class, other) { - specific = false - break - } - } - if specific { - return class, true - } - } - return "", false -} - -// subclassOf reports whether the class iri is ancestor or a subclass of it in -// the SysML ontology; a class of this mapping's extension has no superclass. -func subclassOf(class, ancestor string) bool { - return class == ancestor || strings.HasPrefix(class, rdf.SysML) && strings.HasPrefix(ancestor, rdf.SysML) && - ontology.IsAncestorOrSelf(rdf.LocalName(class), rdf.LocalName(ancestor)) -} - // metaclass returns the local name of the class subject is written as, or "" // when it states none. func (d *decoder) metaclass(subject rdf.Term) string { @@ -1671,6 +1646,14 @@ func (d *decoder) head(el *element) (string, error) { return d.memberPrefixed(el, head) } +// featuresUndeclaredIn202407 are the SysML Feature metaclasses the 202407 metamodel +// table did not declare, so an earlier mapping never owned them as features. +var featuresUndeclaredIn202407 = map[string]bool{ + "ConstructorExpression": true, "FlowEnd": true, "FlowUsage": true, "IndexExpression": true, + "InstantiationExpression": true, "PayloadFeature": true, "SuccessionFlowUsage": true, + "TerminateActionUsage": true, +} + // typeFeatureMember reports whether a type owns el, a feature, through a plain // OwningMembership rather than a FeatureMembership (KerML.xtext TypeFeatureMember). func (d *decoder) typeFeatureMember(el *element) bool { @@ -1683,6 +1666,11 @@ func (d *decoder) typeFeatureMember(el *element) bool { if d.boolOf(el, rdf.SysML+"isVariant") || d.enumeratedValue(el) || d.ownedCrossFeature(el.owner) == el { return false } + // A mapping predating these metaclasses owned them through a plain + // OwningMembership; SysML has no `member`, so that shape is a plain feature. + if !d.kerml(el) && featuresUndeclaredIn202407[el.metaclass] { + return false + } m, owned := d.owningMembership[el.iri] return owned && d.metaclass(rdf.IRI(m.iri)) == mOwningMembership } @@ -2327,7 +2315,7 @@ func (d *decoder) usageHead(el *element, kind ast.UsageKind) (string, error) { if d.boolOf(el, rdf.SysML+"isOrdered") { multPart += " ordered" } - if d.boolOf(el, rdf.SysML+"isNonunique") { + if d.nonunique(el) { multPart += " nonunique" } typed, err := d.referenceList(el, rdf.SysML+relationshipProperty[ast.RelTyping]) @@ -3543,13 +3531,11 @@ func (d *decoder) crossFeatureWords(cross *element) ([]string, error) { case mult != "": words = append(words, mult) } - for _, flag := range []struct { - property string - keyword string - }{{"isOrdered", "ordered"}, {"isNonunique", "nonunique"}} { - if d.boolOf(cross, rdf.SysML+flag.property) { - words = append(words, flag.keyword) - } + if d.boolOf(cross, rdf.SysML+"isOrdered") { + words = append(words, "ordered") + } + if d.nonunique(cross) { + words = append(words, "nonunique") } if len(words) == 0 { return nil, &UnsupportedError{ @@ -4098,6 +4084,15 @@ func (d *decoder) boolOf(el *element, property string) bool { return false } +// nonunique reads `nonunique` from Feature::isUnique false, or from the +// isNonunique an earlier mapping wrote for it. +func (d *decoder) nonunique(el *element) bool { + if unique, stated := d.graph.Lexical(rdf.IRI(el.iri), rdf.SysML+pIsUnique); stated { + return unique == "false" || unique == "0" + } + return d.boolOf(el, rdf.SysML+"isNonunique") +} + // declaresUsage reports whether el is a usage declaration rather than a body // statement of the same metaclass: every declaration states sysx:hasBody. func (d *decoder) declaresUsage(el *element) bool { diff --git a/internal/translate/export/rdf_out.go b/internal/translate/export/rdf_out.go index 341ddbd0c2..e3f21c04a5 100644 --- a/internal/translate/export/rdf_out.go +++ b/internal/translate/export/rdf_out.go @@ -69,6 +69,7 @@ const ( pIsDefault = "isDefault" pIsInitial = "isInitial" pIsEnd = "isEnd" + pIsUnique = "isUnique" pName = "name" pReferences = "references" pConnectorEnd = "connectorEnd" @@ -1446,11 +1447,11 @@ func (e *encoder) encodeMember(h memberHead, owner string) error { {"isPortion", n.IsPortion || n.Portion != ast.PortionNone}, {"isDerived", n.IsDerived}, {"isOrdered", n.IsOrdered}, - {"isNonunique", n.IsNonunique}, {"isAccept", n.IsAccept}, {"isResult", n.IsResult}, {"isParallel", n.IsParallel}, }) + e.nonunique(subject, n.IsNonunique) // `: ~P` types the port by P's conjugate; the usage owns no Conjugation // of its own, so Type::isConjugated stays false on it. if n.HasConjugatedTyping() { @@ -2597,6 +2598,14 @@ func (e *encoder) flags(subject rdf.Term, flags []boolProperty) { } } +// nonunique states `nonunique` as Feature::isUnique false, the metamodel's one +// uniqueness property. +func (e *encoder) nonunique(subject rdf.Term, nonunique bool) { + if nonunique { + e.graph.Add(subject, e.sysml(pIsUnique), rdf.Bool(false)) + } +} + // prefixes maps the `#M` annotations ahead of a declaration as metadata usages // it owns after its body members (PrefixMetadataMember), keyed `#` for the writer. func (e *encoder) prefixes(subject rdf.Term, fqn string, prefixes []*ast.PrefixMetadata, members []ast.Node) error { @@ -2652,8 +2661,8 @@ func (e *encoder) crossFeature(subject rdf.Term, fqn string, n *ast.Usage) error {"isPortion", cross.IsPortion}, {"isDerived", cross.IsDerived}, {"isOrdered", cross.IsOrdered}, - {"isNonunique", cross.IsNonunique}, }) + e.nonunique(crossSubject, cross.IsNonunique) if keyword := directionKeyword(cross.Direction); keyword != "" { e.graph.Add(crossSubject, e.sysml(pDirection), rdf.String(keyword)) } diff --git a/internal/translate/rdf/ontology/README.md b/internal/translate/rdf/ontology/README.md index 91f7b8e3df..1c5d3136ad 100644 --- a/internal/translate/rdf/ontology/README.md +++ b/internal/translate/rdf/ontology/README.md @@ -1,69 +1,75 @@ -# SysML v2 ontology term table +# SysML v2 metamodel term table -`table.go` is generated from the OMG SysML v2 metamodel as -[Open-MBEE/sysmlv2-rdf-ontology](https://github.com/Open-MBEE/sysmlv2-rdf-ontology) -renders it in OWL — `sysml2/owl/www.omg.org/spec/SysML.owl`, version `202407`, -generated there from `SysML.ecore` — plus the checkout's `sysml2/ecore/SysML.ecore` -itself, which supplies each property's upper multiplicity. Neither file is -vendored here (the OWL alone is ~624 KB of third-party RDF/XML): the generator -reads them from a local checkout and records the upstream commit SHA in the -generated header, so the table is reproducible from a header alone. +`table.go` is generated from the OMG SysML v2 metamodel as the pilot implementation +([Systems-Modeling/SysML-v2-Pilot-Implementation](https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation)) +publishes it: `org.omg.sysml/model/SysML.ecore`, at the release and commit +[`scripts/pilot-pin.sh`](../../../../scripts/pilot-pin.sh) pins for every other pilot input. +The metamodel version is the date in the ecore's namespace URI +(`https://www.omg.org/spec/SysML/20250201` → `20250201`). The ecore is not vendored +(~620 KB of third-party XMI); the generated header records the pilot tag, commit and namespace +URI, so the table is reproducible from the header alone. -The table holds, per property, the unqualified local name this tool's encoder -writes (`declaredName`), the metaclass that defines it (`Element`), the full -ontology IRI (`https://www.omg.org/spec/SysML#Element_declaredName`), whether it -is an `owl:ObjectProperty` or an `owl:DatatypeProperty`, its declared -`rdfs:range`, and whether its ecore upper bound is unbounded (`Many` — the -multiplicity the API JSON form spells as an array). It also holds every -`owl:Class` and its named `rdfs:subClassOf` parents, which `IsAncestorOrSelf` -walks for the domain check in `validate.go` and which `PropertyOf` uses to -pick the declaration a given metaclass inherits a name from. +Each ecore `EStructuralFeature` becomes one property, named as the OWL rendering of the +metamodel names it — `https://www.omg.org/spec/SysML#_` — and holding: -The table's contents are counted in one place, -[docs/project/roadmap.md](../../../../docs/project/roadmap.md) § D8, together with -what the gate finds. Some unqualified names are declared by more than one -metaclass, so `LookupProperty` returns every declaration and `AmbiguousNames` -reports those names rather than one being picked silently. - -## What the ontology does not carry +| Field | From the ecore | +|-------|----------------| +| `Name`, `DefiningClass`, `IRI` | the feature's name and the `EClass` declaring it | +| `Kind` | `ObjectProperty` for an `EReference`, `DatatypeProperty` for an `EAttribute` | +| `Range` | the referenced class, the attribute's enumeration, or the XSD/OWL datatype of its primitive (`Boolean` → `xsd:boolean`, `String` → `xsd:string`, `Integer` → `xsd:int`, `Real` → `owl:real`) | +| `Many` | `upperBound="-1"`: the API JSON form spells it as an array | +| `Ordered` | a multi-valued feature without `ordered="false"` (ecore's default is ordered) | +| `Derived` | `derived="true"` | +| `Redefines`, `Subsets` | the `redefines` / `subsets` annotations' references, as `Class::feature` | +| `Opposite` | `eOpposite`, as `Class::feature` | -`SysML.owl` records no ecore abstractness. The only abstractness in the file is -the metamodel's own `Type::isAbstract` property (`sysml:Type_isAbstract`, a -`Type`-domained `owl:DatatypeProperty` about modeled types, not about -metaclasses); the `owl:Class` declarations themselves carry no -abstract/concrete marker. A "the metaclass must be concrete" check is therefore -not possible from this table and is not implemented — see -`docs/project/roadmap.md` § D7 for the abstract-`sysml:Import` finding that check -would otherwise have caught. +Each ecore `EEnum` becomes an `Enumeration`. Its literals keep their declaration order; +enumerations are ordered by name in the generated table. Datatype properties whose range is +in the SysML namespace refer to one of these declarations. -## Regenerating +`Property.QualifiedName` gives the same `Class::feature` spelling, so the three reference fields +can be looked up with `PropertyOf`. Every `EClass` becomes a `Class` with its `eSuperTypes`, which +`IsAncestorOrSelf` walks for the domain check in `validate.go` and `PropertyOf` uses to pick the +declaration a metaclass inherits a name from, and `Abstract` for `abstract="true"`, which the check +reports as an `abstract-class` violation. -Clone the ontology (any revision; the SHA is recorded, not pinned): +The table's contents are counted in one place, +[docs/project/roadmap.md](../../../../docs/project/roadmap.md) § D8, together with what the gate +finds. Some unqualified names are declared by more than one metaclass, so `LookupProperty` returns +every declaration and `AmbiguousNames` reports those names rather than one being picked silently. -```bash -git clone https://github.com/Open-MBEE/sysmlv2-rdf-ontology.git -``` +## Regenerating and checking -Then, from the repository root: +From the repository root: ```bash -go run -C tools ./gen/ontology -ontology /path/to/sysmlv2-rdf-ontology +make ontology-table # ./scripts/download-pilot-metamodel.sh && go run -C tools ./gen/ontology +make ontology-table-check # the same with -check, as CI runs it ``` -or, equivalently, with the checkout in `$SYSMLV2_RDF_ONTOLOGY`: +`scripts/download-pilot-metamodel.sh` fetches the pinned pilot's `org.omg.sysml/model` into +`build/pilot-metamodel/` and stamps it with the pin; the generator refuses a download whose stamp +is not the current pin. It also refuses an ecore whose namespace URI is not +`https://www.omg.org/spec/SysML/`, a feature whose type, opposite, redefined or subsetted +feature names nothing in the ecore, a primitive it has no datatype for, and a name containing `_`, +which would make an IRI ambiguous. `-check` writes nothing and fails when the committed table +differs from what the pin generates. `TestTableFollowsThePilotPin` (`tests/ontology`) fails, with +no download needed, when the pin moves and the table's header still names the previous one. -```bash -SYSMLV2_RDF_ONTOLOGY=/path/to/sysmlv2-rdf-ontology go generate ./internal/translate/rdf/ontology -``` +## Bumping + +The table follows the pilot pin; there is no separate ontology pin to bump. -The generator lives in the `tools/` module and writes the table under the -repository root it finds above its working directory; pass the checkout as an -absolute path. It reads the ontology version from the checkout's `sysml2/README.md` -and the commit SHA from the checkout's on-disk Git metadata. It does not need a -`git` binary, refuses to write a table if any property has no `rdfs:domain` or -if a property IRI disagrees with its domain or names no eStructuralFeature in -the ecore, and overwrites `table.go` in place. -Review the diff, then run -`go test ./internal/translate/rdf/ontology/... ./internal/translate/export/...` — the -export gate compares the golden graphs against the new table and will report -anything the ontology bump changed. +1. Move `PILOT_TAG` and `PILOT_COMMIT` in `scripts/pilot-pin.sh` (see + [docs/project/pilot-corpora.md](../../../../docs/project/pilot-corpora.md) for what else that + moves). +2. `make ontology-table`, then review the diff of `table.go`: classes and properties added, + removed or renamed, and new flags. +3. Update the counts in `tests/ontology/ontology_test.go` and `docs/project/roadmap.md` § D8. +4. `go test ./internal/translate/... ./tests/ontology ./tests/export ./tests/migrate` and the + RDF and API-JSON corpus round-trip gates (`docs/project/rdf-corpus-roundtrip.md`). The export + gate `TestGoldenGraphsMatchOntology` compares the golden graphs against the new table: a + metaclass the export writes that the metamodel renamed, or a property it dropped, appears as a + new violation, and an entry of `tests/export/testdata/ontology-known-violations.txt` the new + table resolves as one to remove. Fix the mapping rather than listing a new violation, and keep + graphs earlier releases wrote readable. diff --git a/internal/translate/rdf/ontology/ontology.go b/internal/translate/rdf/ontology/ontology.go index 0686173cc2..128f98d71b 100644 --- a/internal/translate/rdf/ontology/ontology.go +++ b/internal/translate/rdf/ontology/ontology.go @@ -1,12 +1,11 @@ // Package ontology holds the SysML v2 metamodel term table generated from the -// Open-MBEE OWL rendering, plus the domain/range check built on it. The ontology -// qualifies each property by its defining metaclass (sysml:Element_declaredName) -// where this tool writes the unqualified name (sysml:declaredName), so the table -// records both spellings. It records no ecore abstractness, so a "the metaclass -// must be concrete" check is not possible here. See README.md. +// OMG metamodel's SysML.ecore, plus the domain/range check built on it. The +// table qualifies each property by its defining metaclass in OWL style +// (sysml:Element_declaredName) where this tool writes the unqualified name +// (sysml:declaredName), so it records both spellings. See README.md. package ontology -//go:generate go run -C ../../../../tools ./gen/ontology -ontology $SYSMLV2_RDF_ONTOLOGY +//go:generate go run -C ../../../../tools ./gen/ontology import ( "strings" @@ -31,7 +30,7 @@ func (k PropertyKind) String() string { return "owl:ObjectProperty" } -// Property is one metamodel property as the ontology declares it. +// Property is one metamodel property, an ecore eStructuralFeature. type Property struct { // Name is the unqualified name this tool's encoder writes ("declaredName"). Name string @@ -41,33 +40,70 @@ type Property struct { IRI string // Kind is owl:ObjectProperty or owl:DatatypeProperty. Kind PropertyKind - // Range is the declared rdfs:range IRI, empty when none is declared. + // Range is the rdfs:range IRI: a metaclass or enumeration in the SysML + // namespace, or the XSD/OWL datatype of an ecore primitive. Range string - // Many reports an unbounded upper multiplicity (ecore upperBound -1): - // the API JSON shape is an array. + // Many reports an upper multiplicity above 1 or unbounded (ecore upperBound + // -1): the API JSON shape is an array. Many bool + // Ordered reports a Many property whose values are ordered (ecore + // ordered, which defaults to true); a single-valued property is never Ordered. + Ordered bool + // Derived reports a property the metamodel computes (ecore derived="true") + // rather than one an element owns. + Derived bool + // Redefines and Subsets name the properties this one redefines or subsets, + // as "DefiningClass::name" ("Type::ownedFeature"), when the metamodel states any. + Redefines []string + Subsets []string + // Opposite is the "DefiningClass::name" of the ecore eOpposite, the + // navigable property at the other end of the same association, if any. + Opposite string } -// Class is one metaclass and its named rdfs:subClassOf parents; the anonymous -// cardinality restrictions the ontology also states are not recorded. +// QualifiedName returns the property as "DefiningClass::name", the form +// Redefines, Subsets and Opposite name properties in. +func (p Property) QualifiedName() string { return p.DefiningClass + "::" + p.Name } + +// Class is one metaclass, an ecore EClass, and its eSuperTypes. type Class struct { // Name is the metaclass name ("PartUsage"), its local name in the namespace. Name string + // Abstract reports an abstract metaclass (ecore abstract="true"), one no + // element is an instance of directly. + Abstract bool // Parents are the metaclass names of the declared direct superclasses. Parents []string } +// Enumeration is one metamodel enumeration, an ecore EEnum, with its literals in declaration order. +type Enumeration struct { + Name string + Literals []string +} + // Properties returns every declared property, ordered by IRI. func Properties() []Property { return properties } // Classes returns every declared metaclass, ordered by name. func Classes() []Class { return classes } +// Enumerations returns every declared enumeration, ordered by name. +func Enumerations() []Enumeration { + out := make([]Enumeration, len(enumerations)) + for i, enumeration := range enumerations { + out[i] = enumeration + out[i].Literals = append([]string(nil), enumeration.Literals...) + } + return out +} + // Indexes over the immutable generated table, built once on first lookup. var ( - indexOnce sync.Once - propertiesByName map[string][]Property - classesByName map[string]Class + indexOnce sync.Once + propertiesByName map[string][]Property + classesByName map[string]Class + enumerationsByName map[string]Enumeration ) func index() { @@ -80,6 +116,10 @@ func index() { for _, c := range classes { classesByName[c.Name] = c } + enumerationsByName = make(map[string]Enumeration, len(enumerations)) + for _, enumeration := range enumerations { + enumerationsByName[enumeration.Name] = enumeration + } }) } @@ -97,6 +137,16 @@ func LookupClass(name string) (Class, bool) { return c, ok } +// LookupEnumeration returns the enumeration of a name and whether it is declared. +func LookupEnumeration(name string) (Enumeration, bool) { + index() + enumeration, ok := enumerationsByName[name] + if ok { + enumeration.Literals = append([]string(nil), enumeration.Literals...) + } + return enumeration, ok +} + // PropertyOf returns the declaration of an unqualified property name whose // defining metaclass is metaclass or one of its ancestors; when several // declarations qualify, the one declared on the most specific class. It diff --git a/internal/translate/rdf/ontology/table.go b/internal/translate/rdf/ontology/table.go index 858567bfe3..46eeaf548d 100644 --- a/internal/translate/rdf/ontology/table.go +++ b/internal/translate/rdf/ontology/table.go @@ -1,440 +1,457 @@ // Code generated by tools/gen/ontology. DO NOT EDIT. // -// Source: Open-MBEE/sysmlv2-rdf-ontology, sysml2/owl/www.omg.org/spec/SysML.owl -// Ecore: sysml2/ecore/SysML.ecore (property multiplicities) -// Ontology: SysML v2 metamodel version 202407 (generated from SysML.ecore) -// Commit: a1fda2623d4a0a7b7ace855e12e799dbd5cbaa82 +// Source: https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation.git 2026-08, org.omg.sysml/model/SysML.ecore +// Commit: 692170b71867353b8f90341e61556f49a5beb0e5 +// Metamodel: https://www.omg.org/spec/SysML/20250201 // // Regenerate with (see README.md): // -// go run -C tools ./gen/ontology -ontology +// ./scripts/download-pilot-metamodel.sh +// go run -C tools ./gen/ontology package ontology -// Version is the OMG SysML v2 metamodel version the table was generated from. -const Version = "202407" +// Version is the OMG SysML v2 metamodel version the table was generated from, +// the date in the ecore's namespace URI. +const Version = "20250201" -// SourceCommit is the sysmlv2-rdf-ontology commit the table was generated from. -const SourceCommit = "a1fda2623d4a0a7b7ace855e12e799dbd5cbaa82" +// SourceTag is the pilot implementation release the table was generated from. +const SourceTag = "2026-08" -// properties holds every owl:ObjectProperty and owl:DatatypeProperty the -// ontology declares, ordered by IRI. +// SourceCommit is the pilot implementation commit the table was generated from. +const SourceCommit = "692170b71867353b8f90341e61556f49a5beb0e5" + +// properties holds every eStructuralFeature the metamodel declares, ordered by IRI. var properties = []Property{ - {Name: "payloadArgument", DefiningClass: "AcceptActionUsage", IRI: "https://www.omg.org/spec/SysML#AcceptActionUsage_payloadArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "payloadParameter", DefiningClass: "AcceptActionUsage", IRI: "https://www.omg.org/spec/SysML#AcceptActionUsage_payloadParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ReferenceUsage"}, - {Name: "receiverArgument", DefiningClass: "AcceptActionUsage", IRI: "https://www.omg.org/spec/SysML#AcceptActionUsage_receiverArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "action", DefiningClass: "ActionDefinition", IRI: "https://www.omg.org/spec/SysML#ActionDefinition_action", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Many: true}, - {Name: "actionDefinition", DefiningClass: "ActionUsage", IRI: "https://www.omg.org/spec/SysML#ActionUsage_actionDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Behavior", Many: true}, - {Name: "ownedActorParameter", DefiningClass: "ActorMembership", IRI: "https://www.omg.org/spec/SysML#ActorMembership_ownedActorParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage"}, - {Name: "allocation", DefiningClass: "AllocationDefinition", IRI: "https://www.omg.org/spec/SysML#AllocationDefinition_allocation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AllocationUsage", Many: true}, - {Name: "allocationDefinition", DefiningClass: "AllocationUsage", IRI: "https://www.omg.org/spec/SysML#AllocationUsage_allocationDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AllocationDefinition", Many: true}, - {Name: "resultExpression", DefiningClass: "AnalysisCaseDefinition", IRI: "https://www.omg.org/spec/SysML#AnalysisCaseDefinition_resultExpression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "analysisCaseDefinition", DefiningClass: "AnalysisCaseUsage", IRI: "https://www.omg.org/spec/SysML#AnalysisCaseUsage_analysisCaseDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AnalysisCaseDefinition"}, - {Name: "resultExpression", DefiningClass: "AnalysisCaseUsage", IRI: "https://www.omg.org/spec/SysML#AnalysisCaseUsage_resultExpression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "annotatedElement", DefiningClass: "AnnotatingElement", IRI: "https://www.omg.org/spec/SysML#AnnotatingElement_annotatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true}, - {Name: "annotation", DefiningClass: "AnnotatingElement", IRI: "https://www.omg.org/spec/SysML#AnnotatingElement_annotation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Annotation", Many: true}, - {Name: "ownedAnnotatingRelationship", DefiningClass: "AnnotatingElement", IRI: "https://www.omg.org/spec/SysML#AnnotatingElement_ownedAnnotatingRelationship", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Annotation", Many: true}, - {Name: "annotatedElement", DefiningClass: "Annotation", IRI: "https://www.omg.org/spec/SysML#Annotation_annotatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element"}, - {Name: "annotatingElement", DefiningClass: "Annotation", IRI: "https://www.omg.org/spec/SysML#Annotation_annotatingElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AnnotatingElement"}, - {Name: "owningAnnotatedElement", DefiningClass: "Annotation", IRI: "https://www.omg.org/spec/SysML#Annotation_owningAnnotatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element"}, - {Name: "owningAnnotatingElement", DefiningClass: "Annotation", IRI: "https://www.omg.org/spec/SysML#Annotation_owningAnnotatingElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AnnotatingElement"}, - {Name: "assertedConstraint", DefiningClass: "AssertConstraintUsage", IRI: "https://www.omg.org/spec/SysML#AssertConstraintUsage_assertedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage"}, - {Name: "referent", DefiningClass: "AssignmentActionUsage", IRI: "https://www.omg.org/spec/SysML#AssignmentActionUsage_referent", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "targetArgument", DefiningClass: "AssignmentActionUsage", IRI: "https://www.omg.org/spec/SysML#AssignmentActionUsage_targetArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "valueExpression", DefiningClass: "AssignmentActionUsage", IRI: "https://www.omg.org/spec/SysML#AssignmentActionUsage_valueExpression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "associationEnd", DefiningClass: "Association", IRI: "https://www.omg.org/spec/SysML#Association_associationEnd", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "relatedType", DefiningClass: "Association", IRI: "https://www.omg.org/spec/SysML#Association_relatedType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true}, - {Name: "sourceType", DefiningClass: "Association", IRI: "https://www.omg.org/spec/SysML#Association_sourceType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "targetType", DefiningClass: "Association", IRI: "https://www.omg.org/spec/SysML#Association_targetType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true}, - {Name: "attributeDefinition", DefiningClass: "AttributeUsage", IRI: "https://www.omg.org/spec/SysML#AttributeUsage_attributeDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#DataType", Many: true}, - {Name: "parameter", DefiningClass: "Behavior", IRI: "https://www.omg.org/spec/SysML#Behavior_parameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "step", DefiningClass: "Behavior", IRI: "https://www.omg.org/spec/SysML#Behavior_step", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Step", Many: true}, - {Name: "predicate", DefiningClass: "BooleanExpression", IRI: "https://www.omg.org/spec/SysML#BooleanExpression_predicate", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Predicate"}, - {Name: "calculation", DefiningClass: "CalculationDefinition", IRI: "https://www.omg.org/spec/SysML#CalculationDefinition_calculation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CalculationUsage", Many: true}, - {Name: "calculationDefinition", DefiningClass: "CalculationUsage", IRI: "https://www.omg.org/spec/SysML#CalculationUsage_calculationDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Function"}, - {Name: "actorParameter", DefiningClass: "CaseDefinition", IRI: "https://www.omg.org/spec/SysML#CaseDefinition_actorParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true}, - {Name: "objectiveRequirement", DefiningClass: "CaseDefinition", IRI: "https://www.omg.org/spec/SysML#CaseDefinition_objectiveRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage"}, - {Name: "subjectParameter", DefiningClass: "CaseDefinition", IRI: "https://www.omg.org/spec/SysML#CaseDefinition_subjectParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage"}, - {Name: "actorParameter", DefiningClass: "CaseUsage", IRI: "https://www.omg.org/spec/SysML#CaseUsage_actorParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true}, - {Name: "caseDefinition", DefiningClass: "CaseUsage", IRI: "https://www.omg.org/spec/SysML#CaseUsage_caseDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CaseDefinition"}, - {Name: "objectiveRequirement", DefiningClass: "CaseUsage", IRI: "https://www.omg.org/spec/SysML#CaseUsage_objectiveRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage"}, - {Name: "subjectParameter", DefiningClass: "CaseUsage", IRI: "https://www.omg.org/spec/SysML#CaseUsage_subjectParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage"}, - {Name: "ownedSubclassification", DefiningClass: "Classifier", IRI: "https://www.omg.org/spec/SysML#Classifier_ownedSubclassification", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Subclassification", Many: true}, + {Name: "payloadArgument", DefiningClass: "AcceptActionUsage", IRI: "https://www.omg.org/spec/SysML#AcceptActionUsage_payloadArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, + {Name: "payloadParameter", DefiningClass: "AcceptActionUsage", IRI: "https://www.omg.org/spec/SysML#AcceptActionUsage_payloadParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ReferenceUsage", Derived: true, Subsets: []string{"Usage::nestedReference", "Step::parameter"}}, + {Name: "receiverArgument", DefiningClass: "AcceptActionUsage", IRI: "https://www.omg.org/spec/SysML#AcceptActionUsage_receiverArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, + {Name: "action", DefiningClass: "ActionDefinition", IRI: "https://www.omg.org/spec/SysML#ActionDefinition_action", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Behavior::step", "Definition::usage"}}, + {Name: "actionDefinition", DefiningClass: "ActionUsage", IRI: "https://www.omg.org/spec/SysML#ActionUsage_actionDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Behavior", Many: true, Ordered: true, Derived: true, Redefines: []string{"Step::behavior", "OccurrenceUsage::occurrenceDefinition"}}, + {Name: "ownedActorParameter", DefiningClass: "ActorMembership", IRI: "https://www.omg.org/spec/SysML#ActorMembership_ownedActorParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Derived: true, Redefines: []string{"ParameterMembership::ownedMemberParameter"}}, + {Name: "allocation", DefiningClass: "AllocationDefinition", IRI: "https://www.omg.org/spec/SysML#AllocationDefinition_allocation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AllocationUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::usage"}}, + {Name: "allocationDefinition", DefiningClass: "AllocationUsage", IRI: "https://www.omg.org/spec/SysML#AllocationUsage_allocationDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AllocationDefinition", Many: true, Ordered: true, Derived: true, Redefines: []string{"ConnectionUsage::connectionDefinition"}}, + {Name: "resultExpression", DefiningClass: "AnalysisCaseDefinition", IRI: "https://www.omg.org/spec/SysML#AnalysisCaseDefinition_resultExpression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true, Subsets: []string{"Function::expression", "Type::ownedFeature"}}, + {Name: "analysisCaseDefinition", DefiningClass: "AnalysisCaseUsage", IRI: "https://www.omg.org/spec/SysML#AnalysisCaseUsage_analysisCaseDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AnalysisCaseDefinition", Derived: true, Redefines: []string{"CaseUsage::caseDefinition"}}, + {Name: "resultExpression", DefiningClass: "AnalysisCaseUsage", IRI: "https://www.omg.org/spec/SysML#AnalysisCaseUsage_resultExpression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true, Subsets: []string{"Type::ownedFeature"}}, + {Name: "annotatedElement", DefiningClass: "AnnotatingElement", IRI: "https://www.omg.org/spec/SysML#AnnotatingElement_annotatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Derived: true}, + {Name: "annotation", DefiningClass: "AnnotatingElement", IRI: "https://www.omg.org/spec/SysML#AnnotatingElement_annotation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Annotation", Many: true, Ordered: true, Derived: true, Opposite: "Annotation::annotatingElement"}, + {Name: "ownedAnnotatingRelationship", DefiningClass: "AnnotatingElement", IRI: "https://www.omg.org/spec/SysML#AnnotatingElement_ownedAnnotatingRelationship", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Annotation", Many: true, Ordered: true, Derived: true, Subsets: []string{"AnnotatingElement::annotation", "Element::ownedRelationship"}, Opposite: "Annotation::owningAnnotatingElement"}, + {Name: "owningAnnotatingRelationship", DefiningClass: "AnnotatingElement", IRI: "https://www.omg.org/spec/SysML#AnnotatingElement_owningAnnotatingRelationship", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Annotation", Derived: true, Subsets: []string{"Element::owningRelationship", "AnnotatingElement::annotation"}, Opposite: "Annotation::ownedAnnotatingElement"}, + {Name: "annotatedElement", DefiningClass: "Annotation", IRI: "https://www.omg.org/spec/SysML#Annotation_annotatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Redefines: []string{"Relationship::target"}}, + {Name: "annotatingElement", DefiningClass: "Annotation", IRI: "https://www.omg.org/spec/SysML#Annotation_annotatingElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AnnotatingElement", Derived: true, Redefines: []string{"Relationship::source"}, Opposite: "AnnotatingElement::annotation"}, + {Name: "ownedAnnotatingElement", DefiningClass: "Annotation", IRI: "https://www.omg.org/spec/SysML#Annotation_ownedAnnotatingElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AnnotatingElement", Derived: true, Subsets: []string{"Annotation::annotatingElement", "Relationship::ownedRelatedElement"}, Opposite: "AnnotatingElement::owningAnnotatingRelationship"}, + {Name: "owningAnnotatedElement", DefiningClass: "Annotation", IRI: "https://www.omg.org/spec/SysML#Annotation_owningAnnotatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Derived: true, Subsets: []string{"Annotation::annotatedElement", "Relationship::owningRelatedElement"}, Opposite: "Element::ownedAnnotation"}, + {Name: "owningAnnotatingElement", DefiningClass: "Annotation", IRI: "https://www.omg.org/spec/SysML#Annotation_owningAnnotatingElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AnnotatingElement", Derived: true, Subsets: []string{"Annotation::annotatingElement", "Relationship::owningRelatedElement"}, Opposite: "AnnotatingElement::ownedAnnotatingRelationship"}, + {Name: "assertedConstraint", DefiningClass: "AssertConstraintUsage", IRI: "https://www.omg.org/spec/SysML#AssertConstraintUsage_assertedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Derived: true}, + {Name: "referent", DefiningClass: "AssignmentActionUsage", IRI: "https://www.omg.org/spec/SysML#AssignmentActionUsage_referent", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Subsets: []string{"Namespace::member"}}, + {Name: "targetArgument", DefiningClass: "AssignmentActionUsage", IRI: "https://www.omg.org/spec/SysML#AssignmentActionUsage_targetArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, + {Name: "valueExpression", DefiningClass: "AssignmentActionUsage", IRI: "https://www.omg.org/spec/SysML#AssignmentActionUsage_valueExpression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, + {Name: "associationEnd", DefiningClass: "Association", IRI: "https://www.omg.org/spec/SysML#Association_associationEnd", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Derived: true, Redefines: []string{"Type::endFeature"}}, + {Name: "relatedType", DefiningClass: "Association", IRI: "https://www.omg.org/spec/SysML#Association_relatedType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true, Ordered: true, Derived: true, Redefines: []string{"Relationship::relatedElement"}}, + {Name: "sourceType", DefiningClass: "Association", IRI: "https://www.omg.org/spec/SysML#Association_sourceType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true, Redefines: []string{"Relationship::source"}, Subsets: []string{"Association::relatedType"}}, + {Name: "targetType", DefiningClass: "Association", IRI: "https://www.omg.org/spec/SysML#Association_targetType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true, Derived: true, Redefines: []string{"Relationship::target"}, Subsets: []string{"Association::relatedType"}}, + {Name: "attributeDefinition", DefiningClass: "AttributeUsage", IRI: "https://www.omg.org/spec/SysML#AttributeUsage_attributeDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#DataType", Many: true, Ordered: true, Derived: true, Redefines: []string{"Usage::definition"}}, + {Name: "parameter", DefiningClass: "Behavior", IRI: "https://www.omg.org/spec/SysML#Behavior_parameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Redefines: []string{"Type::directedFeature"}}, + {Name: "step", DefiningClass: "Behavior", IRI: "https://www.omg.org/spec/SysML#Behavior_step", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Step", Many: true, Derived: true, Subsets: []string{"Type::feature"}}, + {Name: "predicate", DefiningClass: "BooleanExpression", IRI: "https://www.omg.org/spec/SysML#BooleanExpression_predicate", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Predicate", Derived: true, Redefines: []string{"Expression::function"}}, + {Name: "calculation", DefiningClass: "CalculationDefinition", IRI: "https://www.omg.org/spec/SysML#CalculationDefinition_calculation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CalculationUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"ActionDefinition::action", "Function::expression"}}, + {Name: "calculationDefinition", DefiningClass: "CalculationUsage", IRI: "https://www.omg.org/spec/SysML#CalculationUsage_calculationDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Function", Derived: true, Redefines: []string{"Expression::function", "ActionUsage::actionDefinition"}}, + {Name: "actorParameter", DefiningClass: "CaseDefinition", IRI: "https://www.omg.org/spec/SysML#CaseDefinition_actorParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Behavior::parameter", "Definition::usage"}}, + {Name: "objectiveRequirement", DefiningClass: "CaseDefinition", IRI: "https://www.omg.org/spec/SysML#CaseDefinition_objectiveRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Derived: true, Subsets: []string{"Definition::usage"}}, + {Name: "subjectParameter", DefiningClass: "CaseDefinition", IRI: "https://www.omg.org/spec/SysML#CaseDefinition_subjectParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Derived: true, Subsets: []string{"Behavior::parameter", "Definition::usage"}}, + {Name: "actorParameter", DefiningClass: "CaseUsage", IRI: "https://www.omg.org/spec/SysML#CaseUsage_actorParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Step::parameter", "Usage::usage"}}, + {Name: "caseDefinition", DefiningClass: "CaseUsage", IRI: "https://www.omg.org/spec/SysML#CaseUsage_caseDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CaseDefinition", Derived: true, Redefines: []string{"CalculationUsage::calculationDefinition"}}, + {Name: "objectiveRequirement", DefiningClass: "CaseUsage", IRI: "https://www.omg.org/spec/SysML#CaseUsage_objectiveRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Derived: true, Subsets: []string{"Usage::usage"}}, + {Name: "subjectParameter", DefiningClass: "CaseUsage", IRI: "https://www.omg.org/spec/SysML#CaseUsage_subjectParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Derived: true, Subsets: []string{"Step::parameter", "Usage::usage"}}, + {Name: "ownedSubclassification", DefiningClass: "Classifier", IRI: "https://www.omg.org/spec/SysML#Classifier_ownedSubclassification", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Subclassification", Many: true, Derived: true, Subsets: []string{"Type::ownedSpecialization"}, Opposite: "Subclassification::owningClassifier"}, {Name: "body", DefiningClass: "Comment", IRI: "https://www.omg.org/spec/SysML#Comment_body", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, {Name: "locale", DefiningClass: "Comment", IRI: "https://www.omg.org/spec/SysML#Comment_locale", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "concernDefinition", DefiningClass: "ConcernUsage", IRI: "https://www.omg.org/spec/SysML#ConcernUsage_concernDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernDefinition"}, - {Name: "originalPortDefinition", DefiningClass: "ConjugatedPortDefinition", IRI: "https://www.omg.org/spec/SysML#ConjugatedPortDefinition_originalPortDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortDefinition"}, - {Name: "ownedPortConjugator", DefiningClass: "ConjugatedPortDefinition", IRI: "https://www.omg.org/spec/SysML#ConjugatedPortDefinition_ownedPortConjugator", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortConjugation"}, - {Name: "conjugatedPortDefinition", DefiningClass: "ConjugatedPortTyping", IRI: "https://www.omg.org/spec/SysML#ConjugatedPortTyping_conjugatedPortDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConjugatedPortDefinition"}, - {Name: "portDefinition", DefiningClass: "ConjugatedPortTyping", IRI: "https://www.omg.org/spec/SysML#ConjugatedPortTyping_portDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortDefinition"}, - {Name: "conjugatedType", DefiningClass: "Conjugation", IRI: "https://www.omg.org/spec/SysML#Conjugation_conjugatedType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "originalType", DefiningClass: "Conjugation", IRI: "https://www.omg.org/spec/SysML#Conjugation_originalType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "owningType", DefiningClass: "Conjugation", IRI: "https://www.omg.org/spec/SysML#Conjugation_owningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "connectionEnd", DefiningClass: "ConnectionDefinition", IRI: "https://www.omg.org/spec/SysML#ConnectionDefinition_connectionEnd", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true}, - {Name: "connectionDefinition", DefiningClass: "ConnectionUsage", IRI: "https://www.omg.org/spec/SysML#ConnectionUsage_connectionDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AssociationStructure", Many: true}, - {Name: "association", DefiningClass: "Connector", IRI: "https://www.omg.org/spec/SysML#Connector_association", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Association", Many: true}, - {Name: "connectorEnd", DefiningClass: "Connector", IRI: "https://www.omg.org/spec/SysML#Connector_connectorEnd", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "relatedFeature", DefiningClass: "Connector", IRI: "https://www.omg.org/spec/SysML#Connector_relatedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "sourceFeature", DefiningClass: "Connector", IRI: "https://www.omg.org/spec/SysML#Connector_sourceFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "targetFeature", DefiningClass: "Connector", IRI: "https://www.omg.org/spec/SysML#Connector_targetFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "constraintDefinition", DefiningClass: "ConstraintUsage", IRI: "https://www.omg.org/spec/SysML#ConstraintUsage_constraintDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Predicate"}, - {Name: "directedUsage", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_directedUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true}, + {Name: "concernDefinition", DefiningClass: "ConcernUsage", IRI: "https://www.omg.org/spec/SysML#ConcernUsage_concernDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernDefinition", Derived: true, Redefines: []string{"RequirementUsage::requirementDefinition"}}, + {Name: "originalPortDefinition", DefiningClass: "ConjugatedPortDefinition", IRI: "https://www.omg.org/spec/SysML#ConjugatedPortDefinition_originalPortDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortDefinition", Derived: true, Redefines: []string{"Element::owningNamespace"}, Opposite: "PortDefinition::conjugatedPortDefinition"}, + {Name: "ownedPortConjugator", DefiningClass: "ConjugatedPortDefinition", IRI: "https://www.omg.org/spec/SysML#ConjugatedPortDefinition_ownedPortConjugator", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortConjugation", Derived: true, Redefines: []string{"Type::ownedConjugator"}, Opposite: "PortConjugation::conjugatedPortDefinition"}, + {Name: "conjugatedPortDefinition", DefiningClass: "ConjugatedPortTyping", IRI: "https://www.omg.org/spec/SysML#ConjugatedPortTyping_conjugatedPortDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConjugatedPortDefinition", Redefines: []string{"FeatureTyping::type"}}, + {Name: "portDefinition", DefiningClass: "ConjugatedPortTyping", IRI: "https://www.omg.org/spec/SysML#ConjugatedPortTyping_portDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortDefinition", Derived: true}, + {Name: "conjugatedType", DefiningClass: "Conjugation", IRI: "https://www.omg.org/spec/SysML#Conjugation_conjugatedType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Redefines: []string{"Relationship::source"}}, + {Name: "originalType", DefiningClass: "Conjugation", IRI: "https://www.omg.org/spec/SysML#Conjugation_originalType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Redefines: []string{"Relationship::target"}}, + {Name: "owningType", DefiningClass: "Conjugation", IRI: "https://www.omg.org/spec/SysML#Conjugation_owningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true, Subsets: []string{"Conjugation::conjugatedType", "Relationship::owningRelatedElement"}, Opposite: "Type::ownedConjugator"}, + {Name: "connectionEnd", DefiningClass: "ConnectionDefinition", IRI: "https://www.omg.org/spec/SysML#ConnectionDefinition_connectionEnd", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true, Ordered: true, Derived: true, Redefines: []string{"Association::associationEnd"}}, + {Name: "connectionDefinition", DefiningClass: "ConnectionUsage", IRI: "https://www.omg.org/spec/SysML#ConnectionUsage_connectionDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AssociationStructure", Many: true, Ordered: true, Derived: true, Redefines: []string{"Connector::association"}, Subsets: []string{"ItemUsage::itemDefinition"}}, + {Name: "association", DefiningClass: "Connector", IRI: "https://www.omg.org/spec/SysML#Connector_association", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Association", Many: true, Ordered: true, Derived: true, Redefines: []string{"Feature::type"}}, + {Name: "connectorEnd", DefiningClass: "Connector", IRI: "https://www.omg.org/spec/SysML#Connector_connectorEnd", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Redefines: []string{"Type::endFeature"}}, + {Name: "defaultFeaturingType", DefiningClass: "Connector", IRI: "https://www.omg.org/spec/SysML#Connector_defaultFeaturingType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true}, + {Name: "relatedFeature", DefiningClass: "Connector", IRI: "https://www.omg.org/spec/SysML#Connector_relatedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Redefines: []string{"Relationship::relatedElement"}}, + {Name: "sourceFeature", DefiningClass: "Connector", IRI: "https://www.omg.org/spec/SysML#Connector_sourceFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Redefines: []string{"Relationship::source"}, Subsets: []string{"Connector::relatedFeature"}}, + {Name: "targetFeature", DefiningClass: "Connector", IRI: "https://www.omg.org/spec/SysML#Connector_targetFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Redefines: []string{"Relationship::target"}, Subsets: []string{"Connector::relatedFeature"}}, + {Name: "constraintDefinition", DefiningClass: "ConstraintUsage", IRI: "https://www.omg.org/spec/SysML#ConstraintUsage_constraintDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Predicate", Derived: true, Redefines: []string{"BooleanExpression::predicate"}}, + {Name: "crossedFeature", DefiningClass: "CrossSubsetting", IRI: "https://www.omg.org/spec/SysML#CrossSubsetting_crossedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Redefines: []string{"Subsetting::subsettedFeature"}}, + {Name: "crossingFeature", DefiningClass: "CrossSubsetting", IRI: "https://www.omg.org/spec/SysML#CrossSubsetting_crossingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Redefines: []string{"Subsetting::owningFeature", "Subsetting::subsettingFeature"}, Opposite: "Feature::ownedCrossSubsetting"}, + {Name: "directedUsage", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_directedUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::directedFeature", "Definition::usage"}}, {Name: "isVariation", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_isVariation", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "ownedAction", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Many: true}, - {Name: "ownedAllocation", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedAllocation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AllocationUsage", Many: true}, - {Name: "ownedAnalysisCase", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedAnalysisCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AnalysisCaseUsage", Many: true}, - {Name: "ownedAttribute", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedAttribute", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AttributeUsage", Many: true}, - {Name: "ownedCalculation", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedCalculation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CalculationUsage", Many: true}, - {Name: "ownedCase", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CaseUsage", Many: true}, - {Name: "ownedConcern", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage", Many: true}, - {Name: "ownedConnection", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedConnection", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConnectorAsUsage", Many: true}, - {Name: "ownedConstraint", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true}, - {Name: "ownedEnumeration", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedEnumeration", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#EnumerationUsage", Many: true}, - {Name: "ownedFlow", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedFlow", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FlowConnectionUsage", Many: true}, - {Name: "ownedInterface", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedInterface", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#InterfaceUsage", Many: true}, - {Name: "ownedItem", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedItem", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ItemUsage", Many: true}, - {Name: "ownedMetadata", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedMetadata", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#MetadataUsage", Many: true}, - {Name: "ownedOccurrence", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedOccurrence", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#OccurrenceUsage", Many: true}, - {Name: "ownedPart", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedPart", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true}, - {Name: "ownedPort", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedPort", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortUsage", Many: true}, - {Name: "ownedReference", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedReference", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ReferenceUsage", Many: true}, - {Name: "ownedRendering", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage", Many: true}, - {Name: "ownedRequirement", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Many: true}, - {Name: "ownedState", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedState", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#StateUsage", Many: true}, - {Name: "ownedTransition", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedTransition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#TransitionUsage", Many: true}, - {Name: "ownedUsage", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true}, - {Name: "ownedUseCase", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedUseCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseUsage", Many: true}, - {Name: "ownedVerificationCase", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedVerificationCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#VerificationCaseUsage", Many: true}, - {Name: "ownedView", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedView", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewUsage", Many: true}, - {Name: "ownedViewpoint", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedViewpoint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewpointUsage", Many: true}, - {Name: "usage", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_usage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true}, - {Name: "variant", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_variant", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true}, - {Name: "variantMembership", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_variantMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#VariantMembership", Many: true}, - {Name: "client", DefiningClass: "Dependency", IRI: "https://www.omg.org/spec/SysML#Dependency_client", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true}, - {Name: "supplier", DefiningClass: "Dependency", IRI: "https://www.omg.org/spec/SysML#Dependency_supplier", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true}, - {Name: "differencingType", DefiningClass: "Differencing", IRI: "https://www.omg.org/spec/SysML#Differencing_differencingType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "typeDifferenced", DefiningClass: "Differencing", IRI: "https://www.omg.org/spec/SysML#Differencing_typeDifferenced", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "disjoiningType", DefiningClass: "Disjoining", IRI: "https://www.omg.org/spec/SysML#Disjoining_disjoiningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "owningType", DefiningClass: "Disjoining", IRI: "https://www.omg.org/spec/SysML#Disjoining_owningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "typeDisjoined", DefiningClass: "Disjoining", IRI: "https://www.omg.org/spec/SysML#Disjoining_typeDisjoined", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "documentedElement", DefiningClass: "Documentation", IRI: "https://www.omg.org/spec/SysML#Documentation_documentedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element"}, - {Name: "condition", DefiningClass: "ElementFilterMembership", IRI: "https://www.omg.org/spec/SysML#ElementFilterMembership_condition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "aliasIds", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_aliasIds", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Many: true}, + {Name: "ownedAction", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedOccurrence"}}, + {Name: "ownedAllocation", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedAllocation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AllocationUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedConnection"}}, + {Name: "ownedAnalysisCase", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedAnalysisCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AnalysisCaseUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedCase"}}, + {Name: "ownedAttribute", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedAttribute", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AttributeUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedUsage"}}, + {Name: "ownedCalculation", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedCalculation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CalculationUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedAction"}}, + {Name: "ownedCase", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CaseUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedCalculation"}}, + {Name: "ownedConcern", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage", Many: true, Derived: true, Subsets: []string{"Definition::ownedRequirement"}}, + {Name: "ownedConnection", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedConnection", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConnectorAsUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedUsage"}}, + {Name: "ownedConstraint", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedOccurrence"}}, + {Name: "ownedEnumeration", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedEnumeration", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#EnumerationUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedAttribute"}}, + {Name: "ownedFlow", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedFlow", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FlowUsage", Many: true, Derived: true, Subsets: []string{"Definition::ownedConnection"}}, + {Name: "ownedInterface", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedInterface", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#InterfaceUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedConnection"}}, + {Name: "ownedItem", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedItem", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ItemUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedOccurrence"}}, + {Name: "ownedMetadata", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedMetadata", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#MetadataUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedItem"}}, + {Name: "ownedOccurrence", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedOccurrence", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#OccurrenceUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedUsage"}}, + {Name: "ownedPart", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedPart", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedItem"}}, + {Name: "ownedPort", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedPort", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedUsage"}}, + {Name: "ownedReference", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedReference", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ReferenceUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedUsage"}}, + {Name: "ownedRendering", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedPart"}}, + {Name: "ownedRequirement", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedConstraint"}}, + {Name: "ownedState", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedState", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#StateUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedAction"}}, + {Name: "ownedTransition", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedTransition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#TransitionUsage", Many: true, Derived: true, Subsets: []string{"Definition::ownedUsage"}}, + {Name: "ownedUsage", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::ownedFeature", "Definition::usage"}, Opposite: "Usage::owningDefinition"}, + {Name: "ownedUseCase", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedUseCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedCase"}}, + {Name: "ownedVerificationCase", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedVerificationCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#VerificationCaseUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedCase"}}, + {Name: "ownedView", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedView", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedPart"}}, + {Name: "ownedViewpoint", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_ownedViewpoint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewpointUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedRequirement"}}, + {Name: "usage", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_usage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::feature"}}, + {Name: "variant", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_variant", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true, Derived: true, Subsets: []string{"Namespace::ownedMember"}}, + {Name: "variantMembership", DefiningClass: "Definition", IRI: "https://www.omg.org/spec/SysML#Definition_variantMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#VariantMembership", Many: true, Derived: true, Subsets: []string{"Namespace::ownedMembership"}}, + {Name: "client", DefiningClass: "Dependency", IRI: "https://www.omg.org/spec/SysML#Dependency_client", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Redefines: []string{"Relationship::source"}}, + {Name: "supplier", DefiningClass: "Dependency", IRI: "https://www.omg.org/spec/SysML#Dependency_supplier", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Redefines: []string{"Relationship::target"}}, + {Name: "differencingType", DefiningClass: "Differencing", IRI: "https://www.omg.org/spec/SysML#Differencing_differencingType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Redefines: []string{"Relationship::target"}}, + {Name: "typeDifferenced", DefiningClass: "Differencing", IRI: "https://www.omg.org/spec/SysML#Differencing_typeDifferenced", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true, Redefines: []string{"Relationship::source"}, Subsets: []string{"Relationship::owningRelatedElement"}, Opposite: "Type::ownedDifferencing"}, + {Name: "disjoiningType", DefiningClass: "Disjoining", IRI: "https://www.omg.org/spec/SysML#Disjoining_disjoiningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Redefines: []string{"Relationship::target"}}, + {Name: "owningType", DefiningClass: "Disjoining", IRI: "https://www.omg.org/spec/SysML#Disjoining_owningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true, Subsets: []string{"Relationship::owningRelatedElement", "Disjoining::typeDisjoined"}, Opposite: "Type::ownedDisjoining"}, + {Name: "typeDisjoined", DefiningClass: "Disjoining", IRI: "https://www.omg.org/spec/SysML#Disjoining_typeDisjoined", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Redefines: []string{"Relationship::source"}}, + {Name: "documentedElement", DefiningClass: "Documentation", IRI: "https://www.omg.org/spec/SysML#Documentation_documentedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Derived: true, Redefines: []string{"AnnotatingElement::annotatedElement"}, Subsets: []string{"Element::owner"}, Opposite: "Element::documentation"}, + {Name: "condition", DefiningClass: "ElementFilterMembership", IRI: "https://www.omg.org/spec/SysML#ElementFilterMembership_condition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true, Redefines: []string{"OwningMembership::ownedMemberElement"}}, + {Name: "aliasIds", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_aliasIds", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Many: true, Ordered: true}, {Name: "declaredName", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_declaredName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, {Name: "declaredShortName", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_declaredShortName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "documentation", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_documentation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Documentation", Many: true}, + {Name: "documentation", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_documentation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Documentation", Many: true, Ordered: true, Derived: true, Subsets: []string{"Element::ownedElement"}, Opposite: "Documentation::documentedElement"}, {Name: "elementId", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_elementId", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, {Name: "isImpliedIncluded", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_isImpliedIncluded", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "isLibraryElement", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_isLibraryElement", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "name", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_name", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "ownedAnnotation", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_ownedAnnotation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Annotation", Many: true}, - {Name: "ownedElement", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_ownedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true}, - {Name: "ownedRelationship", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_ownedRelationship", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Relationship", Many: true}, - {Name: "owner", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_owner", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element"}, - {Name: "owningMembership", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_owningMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#OwningMembership"}, - {Name: "owningNamespace", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_owningNamespace", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Namespace"}, - {Name: "owningRelationship", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_owningRelationship", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Relationship"}, - {Name: "qualifiedName", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_qualifiedName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "shortName", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_shortName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "textualRepresentation", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_textualRepresentation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#TextualRepresentation", Many: true}, - {Name: "enumeratedValue", DefiningClass: "EnumerationDefinition", IRI: "https://www.omg.org/spec/SysML#EnumerationDefinition_enumeratedValue", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#EnumerationUsage", Many: true}, - {Name: "enumerationDefinition", DefiningClass: "EnumerationUsage", IRI: "https://www.omg.org/spec/SysML#EnumerationUsage_enumerationDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#EnumerationDefinition"}, - {Name: "eventOccurrence", DefiningClass: "EventOccurrenceUsage", IRI: "https://www.omg.org/spec/SysML#EventOccurrenceUsage_eventOccurrence", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#OccurrenceUsage"}, - {Name: "exhibitedState", DefiningClass: "ExhibitStateUsage", IRI: "https://www.omg.org/spec/SysML#ExhibitStateUsage_exhibitedState", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#StateUsage"}, - {Name: "function", DefiningClass: "Expression", IRI: "https://www.omg.org/spec/SysML#Expression_function", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Function"}, - {Name: "isModelLevelEvaluable", DefiningClass: "Expression", IRI: "https://www.omg.org/spec/SysML#Expression_isModelLevelEvaluable", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "result", DefiningClass: "Expression", IRI: "https://www.omg.org/spec/SysML#Expression_result", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "targetFeature", DefiningClass: "FeatureChainExpression", IRI: "https://www.omg.org/spec/SysML#FeatureChainExpression_targetFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "chainingFeature", DefiningClass: "FeatureChaining", IRI: "https://www.omg.org/spec/SysML#FeatureChaining_chainingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "featureChained", DefiningClass: "FeatureChaining", IRI: "https://www.omg.org/spec/SysML#FeatureChaining_featureChained", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "featureInverted", DefiningClass: "FeatureInverting", IRI: "https://www.omg.org/spec/SysML#FeatureInverting_featureInverted", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "invertingFeature", DefiningClass: "FeatureInverting", IRI: "https://www.omg.org/spec/SysML#FeatureInverting_invertingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "owningFeature", DefiningClass: "FeatureInverting", IRI: "https://www.omg.org/spec/SysML#FeatureInverting_owningFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "ownedMemberFeature", DefiningClass: "FeatureMembership", IRI: "https://www.omg.org/spec/SysML#FeatureMembership_ownedMemberFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "owningType", DefiningClass: "FeatureMembership", IRI: "https://www.omg.org/spec/SysML#FeatureMembership_owningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "referent", DefiningClass: "FeatureReferenceExpression", IRI: "https://www.omg.org/spec/SysML#FeatureReferenceExpression_referent", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "owningFeature", DefiningClass: "FeatureTyping", IRI: "https://www.omg.org/spec/SysML#FeatureTyping_owningFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "type", DefiningClass: "FeatureTyping", IRI: "https://www.omg.org/spec/SysML#FeatureTyping_type", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "typedFeature", DefiningClass: "FeatureTyping", IRI: "https://www.omg.org/spec/SysML#FeatureTyping_typedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "featureWithValue", DefiningClass: "FeatureValue", IRI: "https://www.omg.org/spec/SysML#FeatureValue_featureWithValue", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, + {Name: "isLibraryElement", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_isLibraryElement", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean", Derived: true}, + {Name: "name", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_name", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Derived: true}, + {Name: "ownedAnnotation", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_ownedAnnotation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Annotation", Many: true, Ordered: true, Derived: true, Subsets: []string{"Element::ownedRelationship"}, Opposite: "Annotation::owningAnnotatedElement"}, + {Name: "ownedElement", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_ownedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Derived: true, Opposite: "Element::owner"}, + {Name: "ownedRelationship", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_ownedRelationship", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Relationship", Many: true, Ordered: true, Opposite: "Relationship::owningRelatedElement"}, + {Name: "owner", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_owner", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Derived: true, Opposite: "Element::ownedElement"}, + {Name: "owningMembership", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_owningMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#OwningMembership", Derived: true, Subsets: []string{"Element::owningRelationship"}, Opposite: "OwningMembership::ownedMemberElement"}, + {Name: "owningNamespace", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_owningNamespace", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Namespace", Derived: true, Opposite: "Namespace::ownedMember"}, + {Name: "owningRelationship", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_owningRelationship", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Relationship", Opposite: "Relationship::ownedRelatedElement"}, + {Name: "qualifiedName", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_qualifiedName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Derived: true}, + {Name: "shortName", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_shortName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Derived: true}, + {Name: "textualRepresentation", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_textualRepresentation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#TextualRepresentation", Many: true, Ordered: true, Derived: true, Subsets: []string{"Element::ownedElement"}, Opposite: "TextualRepresentation::representedElement"}, + {Name: "enumeratedValue", DefiningClass: "EnumerationDefinition", IRI: "https://www.omg.org/spec/SysML#EnumerationDefinition_enumeratedValue", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#EnumerationUsage", Many: true, Ordered: true, Derived: true, Redefines: []string{"Definition::variant"}}, + {Name: "enumerationDefinition", DefiningClass: "EnumerationUsage", IRI: "https://www.omg.org/spec/SysML#EnumerationUsage_enumerationDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#EnumerationDefinition", Derived: true, Redefines: []string{"AttributeUsage::attributeDefinition"}}, + {Name: "eventOccurrence", DefiningClass: "EventOccurrenceUsage", IRI: "https://www.omg.org/spec/SysML#EventOccurrenceUsage_eventOccurrence", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#OccurrenceUsage", Derived: true}, + {Name: "exhibitedState", DefiningClass: "ExhibitStateUsage", IRI: "https://www.omg.org/spec/SysML#ExhibitStateUsage_exhibitedState", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#StateUsage", Derived: true, Redefines: []string{"PerformActionUsage::performedAction"}}, + {Name: "function", DefiningClass: "Expression", IRI: "https://www.omg.org/spec/SysML#Expression_function", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Function", Derived: true, Redefines: []string{"Step::behavior"}}, + {Name: "isModelLevelEvaluable", DefiningClass: "Expression", IRI: "https://www.omg.org/spec/SysML#Expression_isModelLevelEvaluable", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean", Derived: true}, + {Name: "result", DefiningClass: "Expression", IRI: "https://www.omg.org/spec/SysML#Expression_result", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Subsets: []string{"Type::output", "Step::parameter"}}, + {Name: "targetFeature", DefiningClass: "FeatureChainExpression", IRI: "https://www.omg.org/spec/SysML#FeatureChainExpression_targetFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Subsets: []string{"Namespace::member"}}, + {Name: "chainingFeature", DefiningClass: "FeatureChaining", IRI: "https://www.omg.org/spec/SysML#FeatureChaining_chainingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Redefines: []string{"Relationship::target"}}, + {Name: "featureChained", DefiningClass: "FeatureChaining", IRI: "https://www.omg.org/spec/SysML#FeatureChaining_featureChained", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Redefines: []string{"Relationship::source"}, Subsets: []string{"Relationship::owningRelatedElement"}, Opposite: "Feature::ownedFeatureChaining"}, + {Name: "featureInverted", DefiningClass: "FeatureInverting", IRI: "https://www.omg.org/spec/SysML#FeatureInverting_featureInverted", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Redefines: []string{"Relationship::source"}}, + {Name: "invertingFeature", DefiningClass: "FeatureInverting", IRI: "https://www.omg.org/spec/SysML#FeatureInverting_invertingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Redefines: []string{"Relationship::target"}}, + {Name: "owningFeature", DefiningClass: "FeatureInverting", IRI: "https://www.omg.org/spec/SysML#FeatureInverting_owningFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Subsets: []string{"FeatureInverting::featureInverted", "Relationship::owningRelatedElement"}, Opposite: "Feature::ownedFeatureInverting"}, + {Name: "ownedMemberFeature", DefiningClass: "FeatureMembership", IRI: "https://www.omg.org/spec/SysML#FeatureMembership_ownedMemberFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Redefines: []string{"OwningMembership::ownedMemberElement"}, Opposite: "Feature::owningFeatureMembership"}, + {Name: "owningType", DefiningClass: "FeatureMembership", IRI: "https://www.omg.org/spec/SysML#FeatureMembership_owningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true, Redefines: []string{"Membership::membershipOwningNamespace"}, Opposite: "Type::ownedFeatureMembership"}, + {Name: "referent", DefiningClass: "FeatureReferenceExpression", IRI: "https://www.omg.org/spec/SysML#FeatureReferenceExpression_referent", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Subsets: []string{"Namespace::member"}}, + {Name: "owningFeature", DefiningClass: "FeatureTyping", IRI: "https://www.omg.org/spec/SysML#FeatureTyping_owningFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Redefines: []string{"Specialization::owningType"}, Subsets: []string{"FeatureTyping::typedFeature"}, Opposite: "Feature::ownedTyping"}, + {Name: "type", DefiningClass: "FeatureTyping", IRI: "https://www.omg.org/spec/SysML#FeatureTyping_type", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Redefines: []string{"Specialization::general"}}, + {Name: "typedFeature", DefiningClass: "FeatureTyping", IRI: "https://www.omg.org/spec/SysML#FeatureTyping_typedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Redefines: []string{"Specialization::specific"}}, + {Name: "featureWithValue", DefiningClass: "FeatureValue", IRI: "https://www.omg.org/spec/SysML#FeatureValue_featureWithValue", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Subsets: []string{"Membership::membershipOwningNamespace"}}, {Name: "isDefault", DefiningClass: "FeatureValue", IRI: "https://www.omg.org/spec/SysML#FeatureValue_isDefault", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, {Name: "isInitial", DefiningClass: "FeatureValue", IRI: "https://www.omg.org/spec/SysML#FeatureValue_isInitial", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "value", DefiningClass: "FeatureValue", IRI: "https://www.omg.org/spec/SysML#FeatureValue_value", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "chainingFeature", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_chainingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, + {Name: "value", DefiningClass: "FeatureValue", IRI: "https://www.omg.org/spec/SysML#FeatureValue_value", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true, Redefines: []string{"OwningMembership::ownedMemberElement"}}, + {Name: "chainingFeature", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_chainingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true}, + {Name: "crossFeature", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_crossFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true}, {Name: "direction", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_direction", Kind: DatatypeProperty, Range: "https://www.omg.org/spec/SysML#FeatureDirectionKind"}, - {Name: "endOwningType", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_endOwningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "featureTarget", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_featureTarget", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "featuringType", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_featuringType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true}, + {Name: "endOwningType", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_endOwningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true, Subsets: []string{"Feature::owningType"}, Opposite: "Type::ownedEndFeature"}, + {Name: "featureTarget", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_featureTarget", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true}, + {Name: "featuringType", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_featuringType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true, Ordered: true, Derived: true}, {Name: "isComposite", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_isComposite", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, + {Name: "isConstant", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_isConstant", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, {Name: "isDerived", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_isDerived", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, {Name: "isEnd", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_isEnd", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "isNonunique", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_isNonunique", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, {Name: "isOrdered", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_isOrdered", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, {Name: "isPortion", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_isPortion", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "isReadOnly", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_isReadOnly", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, {Name: "isUnique", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_isUnique", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "ownedFeatureChaining", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedFeatureChaining", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureChaining", Many: true}, - {Name: "ownedFeatureInverting", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedFeatureInverting", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureInverting", Many: true}, - {Name: "ownedRedefinition", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedRedefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Redefinition", Many: true}, - {Name: "ownedReferenceSubsetting", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedReferenceSubsetting", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ReferenceSubsetting"}, - {Name: "ownedSubsetting", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedSubsetting", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Subsetting", Many: true}, - {Name: "ownedTypeFeaturing", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedTypeFeaturing", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#TypeFeaturing", Many: true}, - {Name: "ownedTyping", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedTyping", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureTyping", Many: true}, - {Name: "owningFeatureMembership", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_owningFeatureMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureMembership"}, - {Name: "owningType", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_owningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "type", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_type", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true}, - {Name: "feature", DefiningClass: "Featuring", IRI: "https://www.omg.org/spec/SysML#Featuring_feature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "type", DefiningClass: "Featuring", IRI: "https://www.omg.org/spec/SysML#Featuring_type", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "flowConnectionDefinition", DefiningClass: "FlowConnectionUsage", IRI: "https://www.omg.org/spec/SysML#FlowConnectionUsage_flowConnectionDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Interaction", Many: true}, - {Name: "loopVariable", DefiningClass: "ForLoopActionUsage", IRI: "https://www.omg.org/spec/SysML#ForLoopActionUsage_loopVariable", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ReferenceUsage"}, - {Name: "seqArgument", DefiningClass: "ForLoopActionUsage", IRI: "https://www.omg.org/spec/SysML#ForLoopActionUsage_seqArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "ownedConcern", DefiningClass: "FramedConcernMembership", IRI: "https://www.omg.org/spec/SysML#FramedConcernMembership_ownedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage"}, - {Name: "referencedConcern", DefiningClass: "FramedConcernMembership", IRI: "https://www.omg.org/spec/SysML#FramedConcernMembership_referencedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage"}, - {Name: "expression", DefiningClass: "Function", IRI: "https://www.omg.org/spec/SysML#Function_expression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true}, - {Name: "isModelLevelEvaluable", DefiningClass: "Function", IRI: "https://www.omg.org/spec/SysML#Function_isModelLevelEvaluable", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "result", DefiningClass: "Function", IRI: "https://www.omg.org/spec/SysML#Function_result", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "elseAction", DefiningClass: "IfActionUsage", IRI: "https://www.omg.org/spec/SysML#IfActionUsage_elseAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, - {Name: "ifArgument", DefiningClass: "IfActionUsage", IRI: "https://www.omg.org/spec/SysML#IfActionUsage_ifArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "thenAction", DefiningClass: "IfActionUsage", IRI: "https://www.omg.org/spec/SysML#IfActionUsage_thenAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, - {Name: "importOwningNamespace", DefiningClass: "Import", IRI: "https://www.omg.org/spec/SysML#Import_importOwningNamespace", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Namespace"}, - {Name: "importedElement", DefiningClass: "Import", IRI: "https://www.omg.org/spec/SysML#Import_importedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element"}, + {Name: "isVariable", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_isVariable", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, + {Name: "ownedCrossSubsetting", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedCrossSubsetting", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CrossSubsetting", Derived: true, Subsets: []string{"Feature::ownedSubsetting"}, Opposite: "CrossSubsetting::crossingFeature"}, + {Name: "ownedFeatureChaining", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedFeatureChaining", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureChaining", Many: true, Ordered: true, Derived: true, Subsets: []string{"Element::ownedRelationship"}, Opposite: "FeatureChaining::featureChained"}, + {Name: "ownedFeatureInverting", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedFeatureInverting", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureInverting", Many: true, Derived: true, Subsets: []string{"Element::ownedRelationship"}, Opposite: "FeatureInverting::owningFeature"}, + {Name: "ownedRedefinition", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedRedefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Redefinition", Many: true, Derived: true, Subsets: []string{"Feature::ownedSubsetting"}}, + {Name: "ownedReferenceSubsetting", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedReferenceSubsetting", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ReferenceSubsetting", Derived: true, Subsets: []string{"Feature::ownedSubsetting"}, Opposite: "ReferenceSubsetting::referencingFeature"}, + {Name: "ownedSubsetting", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedSubsetting", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Subsetting", Many: true, Derived: true, Subsets: []string{"Type::ownedSpecialization"}, Opposite: "Subsetting::owningFeature"}, + {Name: "ownedTypeFeaturing", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedTypeFeaturing", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#TypeFeaturing", Many: true, Ordered: true, Derived: true, Subsets: []string{"Element::ownedRelationship"}, Opposite: "TypeFeaturing::owningFeatureOfType"}, + {Name: "ownedTyping", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_ownedTyping", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureTyping", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::ownedSpecialization"}, Opposite: "FeatureTyping::owningFeature"}, + {Name: "owningFeatureMembership", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_owningFeatureMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureMembership", Derived: true, Subsets: []string{"Element::owningMembership"}, Opposite: "FeatureMembership::ownedMemberFeature"}, + {Name: "owningType", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_owningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true, Subsets: []string{"Element::owningNamespace", "Feature::featuringType"}, Opposite: "Type::ownedFeature"}, + {Name: "type", DefiningClass: "Feature", IRI: "https://www.omg.org/spec/SysML#Feature_type", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true, Ordered: true, Derived: true}, + {Name: "flowEnd", DefiningClass: "FlowDefinition", IRI: "https://www.omg.org/spec/SysML#FlowDefinition_flowEnd", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true, Derived: true, Redefines: []string{"Association::associationEnd"}}, + {Name: "flowDefinition", DefiningClass: "FlowUsage", IRI: "https://www.omg.org/spec/SysML#FlowUsage_flowDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Interaction", Many: true, Ordered: true, Derived: true, Redefines: []string{"ActionUsage::actionDefinition", "Flow::interaction"}}, + {Name: "flowEnd", DefiningClass: "Flow", IRI: "https://www.omg.org/spec/SysML#Flow_flowEnd", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FlowEnd", Many: true, Ordered: true, Derived: true, Subsets: []string{"Connector::connectorEnd"}}, + {Name: "interaction", DefiningClass: "Flow", IRI: "https://www.omg.org/spec/SysML#Flow_interaction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Interaction", Many: true, Ordered: true, Derived: true, Redefines: []string{"Connector::association", "Step::behavior"}}, + {Name: "payloadFeature", DefiningClass: "Flow", IRI: "https://www.omg.org/spec/SysML#Flow_payloadFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PayloadFeature", Derived: true, Subsets: []string{"Type::ownedFeature"}}, + {Name: "payloadType", DefiningClass: "Flow", IRI: "https://www.omg.org/spec/SysML#Flow_payloadType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Classifier", Many: true, Ordered: true, Derived: true}, + {Name: "sourceOutputFeature", DefiningClass: "Flow", IRI: "https://www.omg.org/spec/SysML#Flow_sourceOutputFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true}, + {Name: "targetInputFeature", DefiningClass: "Flow", IRI: "https://www.omg.org/spec/SysML#Flow_targetInputFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true}, + {Name: "loopVariable", DefiningClass: "ForLoopActionUsage", IRI: "https://www.omg.org/spec/SysML#ForLoopActionUsage_loopVariable", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ReferenceUsage", Derived: true}, + {Name: "seqArgument", DefiningClass: "ForLoopActionUsage", IRI: "https://www.omg.org/spec/SysML#ForLoopActionUsage_seqArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, + {Name: "ownedConcern", DefiningClass: "FramedConcernMembership", IRI: "https://www.omg.org/spec/SysML#FramedConcernMembership_ownedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage", Derived: true, Redefines: []string{"RequirementConstraintMembership::ownedConstraint"}}, + {Name: "referencedConcern", DefiningClass: "FramedConcernMembership", IRI: "https://www.omg.org/spec/SysML#FramedConcernMembership_referencedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage", Derived: true, Redefines: []string{"RequirementConstraintMembership::referencedConstraint"}}, + {Name: "expression", DefiningClass: "Function", IRI: "https://www.omg.org/spec/SysML#Function_expression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true, Derived: true, Subsets: []string{"Behavior::step"}}, + {Name: "isModelLevelEvaluable", DefiningClass: "Function", IRI: "https://www.omg.org/spec/SysML#Function_isModelLevelEvaluable", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean", Derived: true}, + {Name: "result", DefiningClass: "Function", IRI: "https://www.omg.org/spec/SysML#Function_result", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Subsets: []string{"Type::output", "Behavior::parameter"}}, + {Name: "elseAction", DefiningClass: "IfActionUsage", IRI: "https://www.omg.org/spec/SysML#IfActionUsage_elseAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true}, + {Name: "ifArgument", DefiningClass: "IfActionUsage", IRI: "https://www.omg.org/spec/SysML#IfActionUsage_ifArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, + {Name: "thenAction", DefiningClass: "IfActionUsage", IRI: "https://www.omg.org/spec/SysML#IfActionUsage_thenAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true}, + {Name: "importOwningNamespace", DefiningClass: "Import", IRI: "https://www.omg.org/spec/SysML#Import_importOwningNamespace", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Namespace", Derived: true, Redefines: []string{"Relationship::source"}, Subsets: []string{"Relationship::owningRelatedElement"}, Opposite: "Namespace::ownedImport"}, + {Name: "importedElement", DefiningClass: "Import", IRI: "https://www.omg.org/spec/SysML#Import_importedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Derived: true}, {Name: "isImportAll", DefiningClass: "Import", IRI: "https://www.omg.org/spec/SysML#Import_isImportAll", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, {Name: "isRecursive", DefiningClass: "Import", IRI: "https://www.omg.org/spec/SysML#Import_isRecursive", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, {Name: "visibility", DefiningClass: "Import", IRI: "https://www.omg.org/spec/SysML#Import_visibility", Kind: DatatypeProperty, Range: "https://www.omg.org/spec/SysML#VisibilityKind"}, - {Name: "useCaseIncluded", DefiningClass: "IncludeUseCaseUsage", IRI: "https://www.omg.org/spec/SysML#IncludeUseCaseUsage_useCaseIncluded", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseUsage"}, - {Name: "interfaceEnd", DefiningClass: "InterfaceDefinition", IRI: "https://www.omg.org/spec/SysML#InterfaceDefinition_interfaceEnd", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortUsage", Many: true}, - {Name: "interfaceDefinition", DefiningClass: "InterfaceUsage", IRI: "https://www.omg.org/spec/SysML#InterfaceUsage_interfaceDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#InterfaceDefinition", Many: true}, - {Name: "intersectingType", DefiningClass: "Intersecting", IRI: "https://www.omg.org/spec/SysML#Intersecting_intersectingType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "typeIntersected", DefiningClass: "Intersecting", IRI: "https://www.omg.org/spec/SysML#Intersecting_typeIntersected", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, + {Name: "useCaseIncluded", DefiningClass: "IncludeUseCaseUsage", IRI: "https://www.omg.org/spec/SysML#IncludeUseCaseUsage_useCaseIncluded", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseUsage", Derived: true, Redefines: []string{"PerformActionUsage::performedAction"}}, + {Name: "argument", DefiningClass: "InstantiationExpression", IRI: "https://www.omg.org/spec/SysML#InstantiationExpression_argument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true, Ordered: true, Derived: true}, + {Name: "instantiatedType", DefiningClass: "InstantiationExpression", IRI: "https://www.omg.org/spec/SysML#InstantiationExpression_instantiatedType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true, Subsets: []string{"Namespace::member"}}, + {Name: "interfaceEnd", DefiningClass: "InterfaceDefinition", IRI: "https://www.omg.org/spec/SysML#InterfaceDefinition_interfaceEnd", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortUsage", Many: true, Ordered: true, Derived: true, Redefines: []string{"ConnectionDefinition::connectionEnd"}}, + {Name: "interfaceDefinition", DefiningClass: "InterfaceUsage", IRI: "https://www.omg.org/spec/SysML#InterfaceUsage_interfaceDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#InterfaceDefinition", Many: true, Derived: true, Redefines: []string{"ConnectionUsage::connectionDefinition"}}, + {Name: "intersectingType", DefiningClass: "Intersecting", IRI: "https://www.omg.org/spec/SysML#Intersecting_intersectingType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Redefines: []string{"Relationship::target"}}, + {Name: "typeIntersected", DefiningClass: "Intersecting", IRI: "https://www.omg.org/spec/SysML#Intersecting_typeIntersected", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true, Redefines: []string{"Relationship::source"}, Subsets: []string{"Relationship::owningRelatedElement"}, Opposite: "Type::ownedIntersecting"}, {Name: "isNegated", DefiningClass: "Invariant", IRI: "https://www.omg.org/spec/SysML#Invariant_isNegated", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "argument", DefiningClass: "InvocationExpression", IRI: "https://www.omg.org/spec/SysML#InvocationExpression_argument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true}, - {Name: "operand", DefiningClass: "InvocationExpression", IRI: "https://www.omg.org/spec/SysML#InvocationExpression_operand", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true}, - {Name: "interaction", DefiningClass: "ItemFlow", IRI: "https://www.omg.org/spec/SysML#ItemFlow_interaction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Interaction", Many: true}, - {Name: "itemFeature", DefiningClass: "ItemFlow", IRI: "https://www.omg.org/spec/SysML#ItemFlow_itemFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ItemFeature"}, - {Name: "itemFlowEnd", DefiningClass: "ItemFlow", IRI: "https://www.omg.org/spec/SysML#ItemFlow_itemFlowEnd", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ItemFlowEnd"}, - {Name: "itemType", DefiningClass: "ItemFlow", IRI: "https://www.omg.org/spec/SysML#ItemFlow_itemType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Classifier", Many: true}, - {Name: "sourceOutputFeature", DefiningClass: "ItemFlow", IRI: "https://www.omg.org/spec/SysML#ItemFlow_sourceOutputFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "targetInputFeature", DefiningClass: "ItemFlow", IRI: "https://www.omg.org/spec/SysML#ItemFlow_targetInputFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "itemDefinition", DefiningClass: "ItemUsage", IRI: "https://www.omg.org/spec/SysML#ItemUsage_itemDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Structure", Many: true}, + {Name: "operand", DefiningClass: "InvocationExpression", IRI: "https://www.omg.org/spec/SysML#InvocationExpression_operand", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true, Ordered: true, Derived: true}, + {Name: "itemDefinition", DefiningClass: "ItemUsage", IRI: "https://www.omg.org/spec/SysML#ItemUsage_itemDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Structure", Many: true, Ordered: true, Derived: true, Subsets: []string{"OccurrenceUsage::occurrenceDefinition"}}, {Name: "isStandard", DefiningClass: "LibraryPackage", IRI: "https://www.omg.org/spec/SysML#LibraryPackage_isStandard", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, {Name: "value", DefiningClass: "LiteralBoolean", IRI: "https://www.omg.org/spec/SysML#LiteralBoolean_value", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, {Name: "value", DefiningClass: "LiteralInteger", IRI: "https://www.omg.org/spec/SysML#LiteralInteger_value", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#int"}, {Name: "value", DefiningClass: "LiteralRational", IRI: "https://www.omg.org/spec/SysML#LiteralRational_value", Kind: DatatypeProperty, Range: "http://www.w3.org/2002/07/owl#real"}, {Name: "value", DefiningClass: "LiteralString", IRI: "https://www.omg.org/spec/SysML#LiteralString_value", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "bodyAction", DefiningClass: "LoopActionUsage", IRI: "https://www.omg.org/spec/SysML#LoopActionUsage_bodyAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, - {Name: "importedMembership", DefiningClass: "MembershipImport", IRI: "https://www.omg.org/spec/SysML#MembershipImport_importedMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Membership"}, - {Name: "memberElement", DefiningClass: "Membership", IRI: "https://www.omg.org/spec/SysML#Membership_memberElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element"}, - {Name: "memberElementId", DefiningClass: "Membership", IRI: "https://www.omg.org/spec/SysML#Membership_memberElementId", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, + {Name: "bodyAction", DefiningClass: "LoopActionUsage", IRI: "https://www.omg.org/spec/SysML#LoopActionUsage_bodyAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true}, + {Name: "importedMembership", DefiningClass: "MembershipImport", IRI: "https://www.omg.org/spec/SysML#MembershipImport_importedMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Membership", Redefines: []string{"Relationship::target"}}, + {Name: "memberElement", DefiningClass: "Membership", IRI: "https://www.omg.org/spec/SysML#Membership_memberElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Redefines: []string{"Relationship::target"}}, + {Name: "memberElementId", DefiningClass: "Membership", IRI: "https://www.omg.org/spec/SysML#Membership_memberElementId", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Derived: true}, {Name: "memberName", DefiningClass: "Membership", IRI: "https://www.omg.org/spec/SysML#Membership_memberName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, {Name: "memberShortName", DefiningClass: "Membership", IRI: "https://www.omg.org/spec/SysML#Membership_memberShortName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "membershipOwningNamespace", DefiningClass: "Membership", IRI: "https://www.omg.org/spec/SysML#Membership_membershipOwningNamespace", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Namespace"}, + {Name: "membershipOwningNamespace", DefiningClass: "Membership", IRI: "https://www.omg.org/spec/SysML#Membership_membershipOwningNamespace", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Namespace", Derived: true, Redefines: []string{"Relationship::source"}, Subsets: []string{"Relationship::owningRelatedElement"}, Opposite: "Namespace::ownedMembership"}, {Name: "visibility", DefiningClass: "Membership", IRI: "https://www.omg.org/spec/SysML#Membership_visibility", Kind: DatatypeProperty, Range: "https://www.omg.org/spec/SysML#VisibilityKind"}, - {Name: "referencedElement", DefiningClass: "MetadataAccessExpression", IRI: "https://www.omg.org/spec/SysML#MetadataAccessExpression_referencedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element"}, - {Name: "metaclass", DefiningClass: "MetadataFeature", IRI: "https://www.omg.org/spec/SysML#MetadataFeature_metaclass", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Metaclass"}, - {Name: "metadataDefinition", DefiningClass: "MetadataUsage", IRI: "https://www.omg.org/spec/SysML#MetadataUsage_metadataDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Metaclass"}, - {Name: "bound", DefiningClass: "MultiplicityRange", IRI: "https://www.omg.org/spec/SysML#MultiplicityRange_bound", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "lowerBound", DefiningClass: "MultiplicityRange", IRI: "https://www.omg.org/spec/SysML#MultiplicityRange_lowerBound", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "upperBound", DefiningClass: "MultiplicityRange", IRI: "https://www.omg.org/spec/SysML#MultiplicityRange_upperBound", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "importedNamespace", DefiningClass: "NamespaceImport", IRI: "https://www.omg.org/spec/SysML#NamespaceImport_importedNamespace", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Namespace"}, - {Name: "importedMembership", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_importedMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Membership", Many: true}, - {Name: "member", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_member", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true}, - {Name: "membership", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_membership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Membership", Many: true}, - {Name: "ownedImport", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_ownedImport", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Import", Many: true}, - {Name: "ownedMember", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_ownedMember", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true}, - {Name: "ownedMembership", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_ownedMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Membership", Many: true}, - {Name: "ownedObjectiveRequirement", DefiningClass: "ObjectiveMembership", IRI: "https://www.omg.org/spec/SysML#ObjectiveMembership_ownedObjectiveRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage"}, + {Name: "referencedElement", DefiningClass: "MetadataAccessExpression", IRI: "https://www.omg.org/spec/SysML#MetadataAccessExpression_referencedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Derived: true, Subsets: []string{"Namespace::member"}}, + {Name: "metaclass", DefiningClass: "MetadataFeature", IRI: "https://www.omg.org/spec/SysML#MetadataFeature_metaclass", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Metaclass", Derived: true, Subsets: []string{"Feature::type"}}, + {Name: "metadataDefinition", DefiningClass: "MetadataUsage", IRI: "https://www.omg.org/spec/SysML#MetadataUsage_metadataDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Metaclass", Derived: true, Redefines: []string{"ItemUsage::itemDefinition", "MetadataFeature::metaclass"}}, + {Name: "bound", DefiningClass: "MultiplicityRange", IRI: "https://www.omg.org/spec/SysML#MultiplicityRange_bound", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::ownedMember"}}, + {Name: "lowerBound", DefiningClass: "MultiplicityRange", IRI: "https://www.omg.org/spec/SysML#MultiplicityRange_lowerBound", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true, Subsets: []string{"MultiplicityRange::bound"}}, + {Name: "upperBound", DefiningClass: "MultiplicityRange", IRI: "https://www.omg.org/spec/SysML#MultiplicityRange_upperBound", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true, Subsets: []string{"MultiplicityRange::bound"}}, + {Name: "importedNamespace", DefiningClass: "NamespaceImport", IRI: "https://www.omg.org/spec/SysML#NamespaceImport_importedNamespace", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Namespace", Redefines: []string{"Relationship::target"}}, + {Name: "importedMembership", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_importedMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Membership", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::membership"}}, + {Name: "member", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_member", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Derived: true}, + {Name: "membership", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_membership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Membership", Many: true, Ordered: true, Derived: true}, + {Name: "ownedImport", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_ownedImport", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Import", Many: true, Ordered: true, Derived: true, Subsets: []string{"Element::ownedRelationship"}, Opposite: "Import::importOwningNamespace"}, + {Name: "ownedMember", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_ownedMember", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::member"}, Opposite: "Element::owningNamespace"}, + {Name: "ownedMembership", DefiningClass: "Namespace", IRI: "https://www.omg.org/spec/SysML#Namespace_ownedMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Membership", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::membership", "Element::ownedRelationship"}, Opposite: "Membership::membershipOwningNamespace"}, + {Name: "ownedObjectiveRequirement", DefiningClass: "ObjectiveMembership", IRI: "https://www.omg.org/spec/SysML#ObjectiveMembership_ownedObjectiveRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Derived: true, Redefines: []string{"FeatureMembership::ownedMemberFeature"}}, {Name: "isIndividual", DefiningClass: "OccurrenceDefinition", IRI: "https://www.omg.org/spec/SysML#OccurrenceDefinition_isIndividual", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "lifeClass", DefiningClass: "OccurrenceDefinition", IRI: "https://www.omg.org/spec/SysML#OccurrenceDefinition_lifeClass", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#LifeClass"}, - {Name: "individualDefinition", DefiningClass: "OccurrenceUsage", IRI: "https://www.omg.org/spec/SysML#OccurrenceUsage_individualDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#OccurrenceDefinition"}, + {Name: "individualDefinition", DefiningClass: "OccurrenceUsage", IRI: "https://www.omg.org/spec/SysML#OccurrenceUsage_individualDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#OccurrenceDefinition", Derived: true, Subsets: []string{"OccurrenceUsage::occurrenceDefinition"}}, {Name: "isIndividual", DefiningClass: "OccurrenceUsage", IRI: "https://www.omg.org/spec/SysML#OccurrenceUsage_isIndividual", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "occurrenceDefinition", DefiningClass: "OccurrenceUsage", IRI: "https://www.omg.org/spec/SysML#OccurrenceUsage_occurrenceDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Class", Many: true}, + {Name: "occurrenceDefinition", DefiningClass: "OccurrenceUsage", IRI: "https://www.omg.org/spec/SysML#OccurrenceUsage_occurrenceDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Class", Many: true, Ordered: true, Derived: true, Redefines: []string{"Usage::definition"}}, {Name: "portionKind", DefiningClass: "OccurrenceUsage", IRI: "https://www.omg.org/spec/SysML#OccurrenceUsage_portionKind", Kind: DatatypeProperty, Range: "https://www.omg.org/spec/SysML#PortionKind"}, {Name: "operator", DefiningClass: "OperatorExpression", IRI: "https://www.omg.org/spec/SysML#OperatorExpression_operator", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "ownedMemberElement", DefiningClass: "OwningMembership", IRI: "https://www.omg.org/spec/SysML#OwningMembership_ownedMemberElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element"}, - {Name: "ownedMemberElementId", DefiningClass: "OwningMembership", IRI: "https://www.omg.org/spec/SysML#OwningMembership_ownedMemberElementId", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "ownedMemberName", DefiningClass: "OwningMembership", IRI: "https://www.omg.org/spec/SysML#OwningMembership_ownedMemberName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "ownedMemberShortName", DefiningClass: "OwningMembership", IRI: "https://www.omg.org/spec/SysML#OwningMembership_ownedMemberShortName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "filterCondition", DefiningClass: "Package", IRI: "https://www.omg.org/spec/SysML#Package_filterCondition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true}, - {Name: "ownedMemberParameter", DefiningClass: "ParameterMembership", IRI: "https://www.omg.org/spec/SysML#ParameterMembership_ownedMemberParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "partDefinition", DefiningClass: "PartUsage", IRI: "https://www.omg.org/spec/SysML#PartUsage_partDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartDefinition", Many: true}, - {Name: "performedAction", DefiningClass: "PerformActionUsage", IRI: "https://www.omg.org/spec/SysML#PerformActionUsage_performedAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, - {Name: "conjugatedPortDefinition", DefiningClass: "PortConjugation", IRI: "https://www.omg.org/spec/SysML#PortConjugation_conjugatedPortDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConjugatedPortDefinition"}, - {Name: "originalPortDefinition", DefiningClass: "PortConjugation", IRI: "https://www.omg.org/spec/SysML#PortConjugation_originalPortDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortDefinition"}, - {Name: "conjugatedPortDefinition", DefiningClass: "PortDefinition", IRI: "https://www.omg.org/spec/SysML#PortDefinition_conjugatedPortDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConjugatedPortDefinition"}, - {Name: "portDefinition", DefiningClass: "PortUsage", IRI: "https://www.omg.org/spec/SysML#PortUsage_portDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortDefinition", Many: true}, - {Name: "redefinedFeature", DefiningClass: "Redefinition", IRI: "https://www.omg.org/spec/SysML#Redefinition_redefinedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "redefiningFeature", DefiningClass: "Redefinition", IRI: "https://www.omg.org/spec/SysML#Redefinition_redefiningFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "referencedFeature", DefiningClass: "ReferenceSubsetting", IRI: "https://www.omg.org/spec/SysML#ReferenceSubsetting_referencedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "referencingFeature", DefiningClass: "ReferenceSubsetting", IRI: "https://www.omg.org/spec/SysML#ReferenceSubsetting_referencingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, + {Name: "ownedMemberElement", DefiningClass: "OwningMembership", IRI: "https://www.omg.org/spec/SysML#OwningMembership_ownedMemberElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Derived: true, Redefines: []string{"Membership::memberElement"}, Subsets: []string{"Relationship::ownedRelatedElement"}, Opposite: "Element::owningMembership"}, + {Name: "ownedMemberElementId", DefiningClass: "OwningMembership", IRI: "https://www.omg.org/spec/SysML#OwningMembership_ownedMemberElementId", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Derived: true, Redefines: []string{"Membership::memberElementId"}}, + {Name: "ownedMemberName", DefiningClass: "OwningMembership", IRI: "https://www.omg.org/spec/SysML#OwningMembership_ownedMemberName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Derived: true, Redefines: []string{"Membership::memberName"}}, + {Name: "ownedMemberShortName", DefiningClass: "OwningMembership", IRI: "https://www.omg.org/spec/SysML#OwningMembership_ownedMemberShortName", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Derived: true, Redefines: []string{"Membership::memberShortName"}}, + {Name: "filterCondition", DefiningClass: "Package", IRI: "https://www.omg.org/spec/SysML#Package_filterCondition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::ownedMember"}}, + {Name: "ownedMemberParameter", DefiningClass: "ParameterMembership", IRI: "https://www.omg.org/spec/SysML#ParameterMembership_ownedMemberParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Redefines: []string{"FeatureMembership::ownedMemberFeature"}}, + {Name: "partDefinition", DefiningClass: "PartUsage", IRI: "https://www.omg.org/spec/SysML#PartUsage_partDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartDefinition", Many: true, Ordered: true, Derived: true, Subsets: []string{"ItemUsage::itemDefinition"}}, + {Name: "performedAction", DefiningClass: "PerformActionUsage", IRI: "https://www.omg.org/spec/SysML#PerformActionUsage_performedAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true, Redefines: []string{"EventOccurrenceUsage::eventOccurrence"}}, + {Name: "conjugatedPortDefinition", DefiningClass: "PortConjugation", IRI: "https://www.omg.org/spec/SysML#PortConjugation_conjugatedPortDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConjugatedPortDefinition", Derived: true, Redefines: []string{"Conjugation::owningType"}, Opposite: "ConjugatedPortDefinition::ownedPortConjugator"}, + {Name: "originalPortDefinition", DefiningClass: "PortConjugation", IRI: "https://www.omg.org/spec/SysML#PortConjugation_originalPortDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortDefinition", Redefines: []string{"Conjugation::originalType"}}, + {Name: "conjugatedPortDefinition", DefiningClass: "PortDefinition", IRI: "https://www.omg.org/spec/SysML#PortDefinition_conjugatedPortDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConjugatedPortDefinition", Derived: true, Subsets: []string{"Namespace::ownedMember"}, Opposite: "ConjugatedPortDefinition::originalPortDefinition"}, + {Name: "portDefinition", DefiningClass: "PortUsage", IRI: "https://www.omg.org/spec/SysML#PortUsage_portDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortDefinition", Many: true, Ordered: true, Derived: true, Redefines: []string{"OccurrenceUsage::occurrenceDefinition"}}, + {Name: "redefinedFeature", DefiningClass: "Redefinition", IRI: "https://www.omg.org/spec/SysML#Redefinition_redefinedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Redefines: []string{"Subsetting::subsettedFeature"}}, + {Name: "redefiningFeature", DefiningClass: "Redefinition", IRI: "https://www.omg.org/spec/SysML#Redefinition_redefiningFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Redefines: []string{"Subsetting::subsettingFeature"}}, + {Name: "referencedFeature", DefiningClass: "ReferenceSubsetting", IRI: "https://www.omg.org/spec/SysML#ReferenceSubsetting_referencedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Redefines: []string{"Subsetting::subsettedFeature"}}, + {Name: "referencingFeature", DefiningClass: "ReferenceSubsetting", IRI: "https://www.omg.org/spec/SysML#ReferenceSubsetting_referencingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Redefines: []string{"Subsetting::owningFeature", "Subsetting::subsettingFeature"}, Opposite: "Feature::ownedReferenceSubsetting"}, {Name: "isImplied", DefiningClass: "Relationship", IRI: "https://www.omg.org/spec/SysML#Relationship_isImplied", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "ownedRelatedElement", DefiningClass: "Relationship", IRI: "https://www.omg.org/spec/SysML#Relationship_ownedRelatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true}, - {Name: "owningRelatedElement", DefiningClass: "Relationship", IRI: "https://www.omg.org/spec/SysML#Relationship_owningRelatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element"}, - {Name: "relatedElement", DefiningClass: "Relationship", IRI: "https://www.omg.org/spec/SysML#Relationship_relatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true}, - {Name: "source", DefiningClass: "Relationship", IRI: "https://www.omg.org/spec/SysML#Relationship_source", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true}, - {Name: "target", DefiningClass: "Relationship", IRI: "https://www.omg.org/spec/SysML#Relationship_target", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true}, - {Name: "rendering", DefiningClass: "RenderingDefinition", IRI: "https://www.omg.org/spec/SysML#RenderingDefinition_rendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage", Many: true}, - {Name: "renderingDefinition", DefiningClass: "RenderingUsage", IRI: "https://www.omg.org/spec/SysML#RenderingUsage_renderingDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingDefinition"}, + {Name: "ownedRelatedElement", DefiningClass: "Relationship", IRI: "https://www.omg.org/spec/SysML#Relationship_ownedRelatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Subsets: []string{"Relationship::relatedElement"}, Opposite: "Element::owningRelationship"}, + {Name: "owningRelatedElement", DefiningClass: "Relationship", IRI: "https://www.omg.org/spec/SysML#Relationship_owningRelatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Subsets: []string{"Relationship::relatedElement"}, Opposite: "Element::ownedRelationship"}, + {Name: "relatedElement", DefiningClass: "Relationship", IRI: "https://www.omg.org/spec/SysML#Relationship_relatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Derived: true}, + {Name: "source", DefiningClass: "Relationship", IRI: "https://www.omg.org/spec/SysML#Relationship_source", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Subsets: []string{"Relationship::relatedElement"}}, + {Name: "target", DefiningClass: "Relationship", IRI: "https://www.omg.org/spec/SysML#Relationship_target", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Subsets: []string{"Relationship::relatedElement"}}, + {Name: "rendering", DefiningClass: "RenderingDefinition", IRI: "https://www.omg.org/spec/SysML#RenderingDefinition_rendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::usage"}}, + {Name: "renderingDefinition", DefiningClass: "RenderingUsage", IRI: "https://www.omg.org/spec/SysML#RenderingUsage_renderingDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingDefinition", Derived: true, Redefines: []string{"PartUsage::partDefinition"}}, {Name: "kind", DefiningClass: "RequirementConstraintMembership", IRI: "https://www.omg.org/spec/SysML#RequirementConstraintMembership_kind", Kind: DatatypeProperty, Range: "https://www.omg.org/spec/SysML#RequirementConstraintKind"}, - {Name: "ownedConstraint", DefiningClass: "RequirementConstraintMembership", IRI: "https://www.omg.org/spec/SysML#RequirementConstraintMembership_ownedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage"}, - {Name: "referencedConstraint", DefiningClass: "RequirementConstraintMembership", IRI: "https://www.omg.org/spec/SysML#RequirementConstraintMembership_referencedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage"}, - {Name: "actorParameter", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_actorParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true}, - {Name: "assumedConstraint", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_assumedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true}, - {Name: "framedConcern", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_framedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage", Many: true}, - {Name: "reqId", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_reqId", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "requiredConstraint", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_requiredConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true}, - {Name: "stakeholderParameter", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_stakeholderParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true}, - {Name: "subjectParameter", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_subjectParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage"}, - {Name: "text", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_text", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Many: true}, - {Name: "actorParameter", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_actorParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true}, - {Name: "assumedConstraint", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_assumedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true}, - {Name: "framedConcern", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_framedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage", Many: true}, - {Name: "reqId", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_reqId", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "requiredConstraint", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_requiredConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true}, - {Name: "requirementDefinition", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_requirementDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementDefinition"}, - {Name: "stakeholderParameter", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_stakeholderParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true}, - {Name: "subjectParameter", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_subjectParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage"}, - {Name: "text", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_text", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Many: true}, - {Name: "ownedRequirement", DefiningClass: "RequirementVerificationMembership", IRI: "https://www.omg.org/spec/SysML#RequirementVerificationMembership_ownedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage"}, - {Name: "verifiedRequirement", DefiningClass: "RequirementVerificationMembership", IRI: "https://www.omg.org/spec/SysML#RequirementVerificationMembership_verifiedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage"}, - {Name: "ownedResultExpression", DefiningClass: "ResultExpressionMembership", IRI: "https://www.omg.org/spec/SysML#ResultExpressionMembership_ownedResultExpression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "satisfiedRequirement", DefiningClass: "SatisfyRequirementUsage", IRI: "https://www.omg.org/spec/SysML#SatisfyRequirementUsage_satisfiedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage"}, - {Name: "satisfyingFeature", DefiningClass: "SatisfyRequirementUsage", IRI: "https://www.omg.org/spec/SysML#SatisfyRequirementUsage_satisfyingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "payloadArgument", DefiningClass: "SendActionUsage", IRI: "https://www.omg.org/spec/SysML#SendActionUsage_payloadArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "receiverArgument", DefiningClass: "SendActionUsage", IRI: "https://www.omg.org/spec/SysML#SendActionUsage_receiverArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "senderArgument", DefiningClass: "SendActionUsage", IRI: "https://www.omg.org/spec/SysML#SendActionUsage_senderArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "general", DefiningClass: "Specialization", IRI: "https://www.omg.org/spec/SysML#Specialization_general", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "owningType", DefiningClass: "Specialization", IRI: "https://www.omg.org/spec/SysML#Specialization_owningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "specific", DefiningClass: "Specialization", IRI: "https://www.omg.org/spec/SysML#Specialization_specific", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "ownedStakeholderParameter", DefiningClass: "StakeholderMembership", IRI: "https://www.omg.org/spec/SysML#StakeholderMembership_ownedStakeholderParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage"}, - {Name: "doAction", DefiningClass: "StateDefinition", IRI: "https://www.omg.org/spec/SysML#StateDefinition_doAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, - {Name: "entryAction", DefiningClass: "StateDefinition", IRI: "https://www.omg.org/spec/SysML#StateDefinition_entryAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, - {Name: "exitAction", DefiningClass: "StateDefinition", IRI: "https://www.omg.org/spec/SysML#StateDefinition_exitAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, + {Name: "ownedConstraint", DefiningClass: "RequirementConstraintMembership", IRI: "https://www.omg.org/spec/SysML#RequirementConstraintMembership_ownedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Derived: true, Redefines: []string{"FeatureMembership::ownedMemberFeature"}}, + {Name: "referencedConstraint", DefiningClass: "RequirementConstraintMembership", IRI: "https://www.omg.org/spec/SysML#RequirementConstraintMembership_referencedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Derived: true}, + {Name: "actorParameter", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_actorParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Behavior::parameter", "Definition::usage"}}, + {Name: "assumedConstraint", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_assumedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::ownedFeature"}}, + {Name: "framedConcern", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_framedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"RequirementDefinition::requiredConstraint"}}, + {Name: "reqId", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_reqId", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Redefines: []string{"Element::declaredShortName"}}, + {Name: "requiredConstraint", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_requiredConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::ownedFeature"}}, + {Name: "stakeholderParameter", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_stakeholderParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Behavior::parameter", "Definition::usage"}}, + {Name: "subjectParameter", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_subjectParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Derived: true, Subsets: []string{"Behavior::parameter", "Definition::usage"}}, + {Name: "text", DefiningClass: "RequirementDefinition", IRI: "https://www.omg.org/spec/SysML#RequirementDefinition_text", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Many: true, Derived: true}, + {Name: "actorParameter", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_actorParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Step::parameter", "Usage::usage"}}, + {Name: "assumedConstraint", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_assumedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::ownedFeature"}}, + {Name: "framedConcern", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_framedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"RequirementUsage::requiredConstraint"}}, + {Name: "reqId", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_reqId", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Redefines: []string{"Element::declaredShortName"}}, + {Name: "requiredConstraint", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_requiredConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::ownedFeature"}}, + {Name: "requirementDefinition", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_requirementDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementDefinition", Derived: true, Redefines: []string{"ConstraintUsage::constraintDefinition"}}, + {Name: "stakeholderParameter", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_stakeholderParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Step::parameter", "Usage::usage"}}, + {Name: "subjectParameter", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_subjectParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Derived: true, Subsets: []string{"Step::parameter", "Usage::usage"}}, + {Name: "text", DefiningClass: "RequirementUsage", IRI: "https://www.omg.org/spec/SysML#RequirementUsage_text", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string", Many: true, Derived: true}, + {Name: "ownedRequirement", DefiningClass: "RequirementVerificationMembership", IRI: "https://www.omg.org/spec/SysML#RequirementVerificationMembership_ownedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Derived: true, Redefines: []string{"RequirementConstraintMembership::ownedConstraint"}}, + {Name: "verifiedRequirement", DefiningClass: "RequirementVerificationMembership", IRI: "https://www.omg.org/spec/SysML#RequirementVerificationMembership_verifiedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Derived: true, Redefines: []string{"RequirementConstraintMembership::referencedConstraint"}}, + {Name: "ownedResultExpression", DefiningClass: "ResultExpressionMembership", IRI: "https://www.omg.org/spec/SysML#ResultExpressionMembership_ownedResultExpression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true, Redefines: []string{"FeatureMembership::ownedMemberFeature"}}, + {Name: "satisfiedRequirement", DefiningClass: "SatisfyRequirementUsage", IRI: "https://www.omg.org/spec/SysML#SatisfyRequirementUsage_satisfiedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Derived: true, Redefines: []string{"AssertConstraintUsage::assertedConstraint"}}, + {Name: "satisfyingFeature", DefiningClass: "SatisfyRequirementUsage", IRI: "https://www.omg.org/spec/SysML#SatisfyRequirementUsage_satisfyingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true}, + {Name: "payloadArgument", DefiningClass: "SendActionUsage", IRI: "https://www.omg.org/spec/SysML#SendActionUsage_payloadArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, + {Name: "receiverArgument", DefiningClass: "SendActionUsage", IRI: "https://www.omg.org/spec/SysML#SendActionUsage_receiverArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, + {Name: "senderArgument", DefiningClass: "SendActionUsage", IRI: "https://www.omg.org/spec/SysML#SendActionUsage_senderArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, + {Name: "general", DefiningClass: "Specialization", IRI: "https://www.omg.org/spec/SysML#Specialization_general", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Redefines: []string{"Relationship::target"}}, + {Name: "owningType", DefiningClass: "Specialization", IRI: "https://www.omg.org/spec/SysML#Specialization_owningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true, Subsets: []string{"Relationship::owningRelatedElement", "Specialization::specific"}, Opposite: "Type::ownedSpecialization"}, + {Name: "specific", DefiningClass: "Specialization", IRI: "https://www.omg.org/spec/SysML#Specialization_specific", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Redefines: []string{"Relationship::source"}}, + {Name: "ownedStakeholderParameter", DefiningClass: "StakeholderMembership", IRI: "https://www.omg.org/spec/SysML#StakeholderMembership_ownedStakeholderParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Derived: true, Redefines: []string{"ParameterMembership::ownedMemberParameter"}}, + {Name: "doAction", DefiningClass: "StateDefinition", IRI: "https://www.omg.org/spec/SysML#StateDefinition_doAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true}, + {Name: "entryAction", DefiningClass: "StateDefinition", IRI: "https://www.omg.org/spec/SysML#StateDefinition_entryAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true}, + {Name: "exitAction", DefiningClass: "StateDefinition", IRI: "https://www.omg.org/spec/SysML#StateDefinition_exitAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true}, {Name: "isParallel", DefiningClass: "StateDefinition", IRI: "https://www.omg.org/spec/SysML#StateDefinition_isParallel", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "state", DefiningClass: "StateDefinition", IRI: "https://www.omg.org/spec/SysML#StateDefinition_state", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#StateUsage", Many: true}, - {Name: "action", DefiningClass: "StateSubactionMembership", IRI: "https://www.omg.org/spec/SysML#StateSubactionMembership_action", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, + {Name: "state", DefiningClass: "StateDefinition", IRI: "https://www.omg.org/spec/SysML#StateDefinition_state", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#StateUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"ActionDefinition::action"}}, + {Name: "action", DefiningClass: "StateSubactionMembership", IRI: "https://www.omg.org/spec/SysML#StateSubactionMembership_action", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true, Redefines: []string{"FeatureMembership::ownedMemberFeature"}}, {Name: "kind", DefiningClass: "StateSubactionMembership", IRI: "https://www.omg.org/spec/SysML#StateSubactionMembership_kind", Kind: DatatypeProperty, Range: "https://www.omg.org/spec/SysML#StateSubactionKind"}, - {Name: "doAction", DefiningClass: "StateUsage", IRI: "https://www.omg.org/spec/SysML#StateUsage_doAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, - {Name: "entryAction", DefiningClass: "StateUsage", IRI: "https://www.omg.org/spec/SysML#StateUsage_entryAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, - {Name: "exitAction", DefiningClass: "StateUsage", IRI: "https://www.omg.org/spec/SysML#StateUsage_exitAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, + {Name: "doAction", DefiningClass: "StateUsage", IRI: "https://www.omg.org/spec/SysML#StateUsage_doAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true}, + {Name: "entryAction", DefiningClass: "StateUsage", IRI: "https://www.omg.org/spec/SysML#StateUsage_entryAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true}, + {Name: "exitAction", DefiningClass: "StateUsage", IRI: "https://www.omg.org/spec/SysML#StateUsage_exitAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true}, {Name: "isParallel", DefiningClass: "StateUsage", IRI: "https://www.omg.org/spec/SysML#StateUsage_isParallel", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "stateDefinition", DefiningClass: "StateUsage", IRI: "https://www.omg.org/spec/SysML#StateUsage_stateDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Behavior", Many: true}, - {Name: "behavior", DefiningClass: "Step", IRI: "https://www.omg.org/spec/SysML#Step_behavior", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Behavior", Many: true}, - {Name: "parameter", DefiningClass: "Step", IRI: "https://www.omg.org/spec/SysML#Step_parameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "owningClassifier", DefiningClass: "Subclassification", IRI: "https://www.omg.org/spec/SysML#Subclassification_owningClassifier", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Classifier"}, - {Name: "subclassifier", DefiningClass: "Subclassification", IRI: "https://www.omg.org/spec/SysML#Subclassification_subclassifier", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Classifier"}, - {Name: "superclassifier", DefiningClass: "Subclassification", IRI: "https://www.omg.org/spec/SysML#Subclassification_superclassifier", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Classifier"}, - {Name: "ownedSubjectParameter", DefiningClass: "SubjectMembership", IRI: "https://www.omg.org/spec/SysML#SubjectMembership_ownedSubjectParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage"}, - {Name: "owningFeature", DefiningClass: "Subsetting", IRI: "https://www.omg.org/spec/SysML#Subsetting_owningFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "subsettedFeature", DefiningClass: "Subsetting", IRI: "https://www.omg.org/spec/SysML#Subsetting_subsettedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "subsettingFeature", DefiningClass: "Subsetting", IRI: "https://www.omg.org/spec/SysML#Subsetting_subsettingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "effectStep", DefiningClass: "Succession", IRI: "https://www.omg.org/spec/SysML#Succession_effectStep", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Step", Many: true}, - {Name: "guardExpression", DefiningClass: "Succession", IRI: "https://www.omg.org/spec/SysML#Succession_guardExpression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true}, - {Name: "transitionStep", DefiningClass: "Succession", IRI: "https://www.omg.org/spec/SysML#Succession_transitionStep", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Step"}, - {Name: "triggerStep", DefiningClass: "Succession", IRI: "https://www.omg.org/spec/SysML#Succession_triggerStep", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Step", Many: true}, + {Name: "stateDefinition", DefiningClass: "StateUsage", IRI: "https://www.omg.org/spec/SysML#StateUsage_stateDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Behavior", Many: true, Ordered: true, Derived: true, Redefines: []string{"ActionUsage::actionDefinition"}}, + {Name: "behavior", DefiningClass: "Step", IRI: "https://www.omg.org/spec/SysML#Step_behavior", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Behavior", Many: true, Ordered: true, Derived: true, Subsets: []string{"Feature::type"}}, + {Name: "parameter", DefiningClass: "Step", IRI: "https://www.omg.org/spec/SysML#Step_parameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Redefines: []string{"Type::directedFeature"}}, + {Name: "owningClassifier", DefiningClass: "Subclassification", IRI: "https://www.omg.org/spec/SysML#Subclassification_owningClassifier", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Classifier", Derived: true, Redefines: []string{"Specialization::owningType"}, Opposite: "Classifier::ownedSubclassification"}, + {Name: "subclassifier", DefiningClass: "Subclassification", IRI: "https://www.omg.org/spec/SysML#Subclassification_subclassifier", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Classifier", Redefines: []string{"Specialization::specific"}}, + {Name: "superclassifier", DefiningClass: "Subclassification", IRI: "https://www.omg.org/spec/SysML#Subclassification_superclassifier", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Classifier", Redefines: []string{"Specialization::general"}}, + {Name: "ownedSubjectParameter", DefiningClass: "SubjectMembership", IRI: "https://www.omg.org/spec/SysML#SubjectMembership_ownedSubjectParameter", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Derived: true, Redefines: []string{"ParameterMembership::ownedMemberParameter"}}, + {Name: "owningFeature", DefiningClass: "Subsetting", IRI: "https://www.omg.org/spec/SysML#Subsetting_owningFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Redefines: []string{"Specialization::owningType"}, Subsets: []string{"Subsetting::subsettingFeature"}, Opposite: "Feature::ownedSubsetting"}, + {Name: "subsettedFeature", DefiningClass: "Subsetting", IRI: "https://www.omg.org/spec/SysML#Subsetting_subsettedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Redefines: []string{"Specialization::general"}}, + {Name: "subsettingFeature", DefiningClass: "Subsetting", IRI: "https://www.omg.org/spec/SysML#Subsetting_subsettingFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Redefines: []string{"Specialization::specific"}}, + {Name: "terminatedOccurrenceArgument", DefiningClass: "TerminateActionUsage", IRI: "https://www.omg.org/spec/SysML#TerminateActionUsage_terminatedOccurrenceArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, {Name: "body", DefiningClass: "TextualRepresentation", IRI: "https://www.omg.org/spec/SysML#TextualRepresentation_body", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, {Name: "language", DefiningClass: "TextualRepresentation", IRI: "https://www.omg.org/spec/SysML#TextualRepresentation_language", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "representedElement", DefiningClass: "TextualRepresentation", IRI: "https://www.omg.org/spec/SysML#TextualRepresentation_representedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element"}, + {Name: "representedElement", DefiningClass: "TextualRepresentation", IRI: "https://www.omg.org/spec/SysML#TextualRepresentation_representedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Derived: true, Redefines: []string{"AnnotatingElement::annotatedElement"}, Subsets: []string{"Element::owner"}, Opposite: "Element::textualRepresentation"}, {Name: "kind", DefiningClass: "TransitionFeatureMembership", IRI: "https://www.omg.org/spec/SysML#TransitionFeatureMembership_kind", Kind: DatatypeProperty, Range: "https://www.omg.org/spec/SysML#TransitionFeatureKind"}, - {Name: "transitionFeature", DefiningClass: "TransitionFeatureMembership", IRI: "https://www.omg.org/spec/SysML#TransitionFeatureMembership_transitionFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Step"}, - {Name: "effectAction", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_effectAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Many: true}, - {Name: "guardExpression", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_guardExpression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true}, - {Name: "source", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_source", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, - {Name: "succession", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_succession", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Succession"}, - {Name: "target", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_target", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage"}, - {Name: "triggerAction", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_triggerAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AcceptActionUsage", Many: true}, + {Name: "transitionFeature", DefiningClass: "TransitionFeatureMembership", IRI: "https://www.omg.org/spec/SysML#TransitionFeatureMembership_transitionFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Step", Derived: true, Redefines: []string{"FeatureMembership::ownedMemberFeature"}}, + {Name: "effectAction", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_effectAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Many: true, Derived: true, Subsets: []string{"Type::feature"}}, + {Name: "guardExpression", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_guardExpression", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true, Derived: true, Subsets: []string{"Type::ownedFeature"}}, + {Name: "source", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_source", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true}, + {Name: "succession", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_succession", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Succession", Derived: true, Subsets: []string{"Namespace::ownedMember"}}, + {Name: "target", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_target", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Derived: true}, + {Name: "triggerAction", DefiningClass: "TransitionUsage", IRI: "https://www.omg.org/spec/SysML#TransitionUsage_triggerAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AcceptActionUsage", Many: true, Derived: true, Subsets: []string{"Type::ownedFeature"}}, {Name: "kind", DefiningClass: "TriggerInvocationExpression", IRI: "https://www.omg.org/spec/SysML#TriggerInvocationExpression_kind", Kind: DatatypeProperty, Range: "https://www.omg.org/spec/SysML#TriggerKind"}, - {Name: "featureOfType", DefiningClass: "TypeFeaturing", IRI: "https://www.omg.org/spec/SysML#TypeFeaturing_featureOfType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "featuringType", DefiningClass: "TypeFeaturing", IRI: "https://www.omg.org/spec/SysML#TypeFeaturing_featuringType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "owningFeatureOfType", DefiningClass: "TypeFeaturing", IRI: "https://www.omg.org/spec/SysML#TypeFeaturing_owningFeatureOfType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature"}, - {Name: "differencingType", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_differencingType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true}, - {Name: "directedFeature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_directedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "endFeature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_endFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "feature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_feature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "featureMembership", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_featureMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureMembership", Many: true}, - {Name: "inheritedFeature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_inheritedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "inheritedMembership", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_inheritedMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Membership", Many: true}, - {Name: "input", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_input", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "intersectingType", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_intersectingType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true}, + {Name: "featureOfType", DefiningClass: "TypeFeaturing", IRI: "https://www.omg.org/spec/SysML#TypeFeaturing_featureOfType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Redefines: []string{"Relationship::source"}}, + {Name: "featuringType", DefiningClass: "TypeFeaturing", IRI: "https://www.omg.org/spec/SysML#TypeFeaturing_featuringType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Redefines: []string{"Relationship::target"}}, + {Name: "owningFeatureOfType", DefiningClass: "TypeFeaturing", IRI: "https://www.omg.org/spec/SysML#TypeFeaturing_owningFeatureOfType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Derived: true, Subsets: []string{"Relationship::owningRelatedElement", "TypeFeaturing::featureOfType"}, Opposite: "Feature::ownedTypeFeaturing"}, + {Name: "differencingType", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_differencingType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true, Ordered: true, Derived: true}, + {Name: "directedFeature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_directedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::feature"}}, + {Name: "endFeature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_endFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::feature"}}, + {Name: "feature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_feature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::member"}}, + {Name: "featureMembership", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_featureMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureMembership", Many: true, Ordered: true, Derived: true}, + {Name: "inheritedFeature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_inheritedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::feature"}}, + {Name: "inheritedMembership", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_inheritedMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Membership", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::membership"}}, + {Name: "input", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_input", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::directedFeature"}}, + {Name: "intersectingType", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_intersectingType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true, Ordered: true, Derived: true}, {Name: "isAbstract", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_isAbstract", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "isConjugated", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_isConjugated", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, + {Name: "isConjugated", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_isConjugated", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean", Derived: true}, {Name: "isSufficient", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_isSufficient", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "multiplicity", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_multiplicity", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Multiplicity"}, - {Name: "output", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_output", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "ownedConjugator", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedConjugator", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Conjugation"}, - {Name: "ownedDifferencing", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedDifferencing", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Differencing", Many: true}, - {Name: "ownedDisjoining", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedDisjoining", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Disjoining", Many: true}, - {Name: "ownedEndFeature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedEndFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "ownedFeature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true}, - {Name: "ownedFeatureMembership", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedFeatureMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureMembership", Many: true}, - {Name: "ownedIntersecting", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedIntersecting", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Intersecting", Many: true}, - {Name: "ownedSpecialization", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedSpecialization", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Specialization", Many: true}, - {Name: "ownedUnioning", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedUnioning", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Unioning", Many: true}, - {Name: "unioningType", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_unioningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true}, - {Name: "typeUnioned", DefiningClass: "Unioning", IRI: "https://www.omg.org/spec/SysML#Unioning_typeUnioned", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "unioningType", DefiningClass: "Unioning", IRI: "https://www.omg.org/spec/SysML#Unioning_unioningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type"}, - {Name: "definition", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_definition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Classifier", Many: true}, - {Name: "directedUsage", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_directedUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true}, - {Name: "isReference", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_isReference", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, + {Name: "multiplicity", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_multiplicity", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Multiplicity", Derived: true, Subsets: []string{"Namespace::ownedMember"}}, + {Name: "output", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_output", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::directedFeature"}}, + {Name: "ownedConjugator", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedConjugator", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Conjugation", Derived: true, Subsets: []string{"Element::ownedRelationship"}, Opposite: "Conjugation::owningType"}, + {Name: "ownedDifferencing", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedDifferencing", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Differencing", Many: true, Ordered: true, Derived: true, Subsets: []string{"Element::ownedRelationship"}, Opposite: "Differencing::typeDifferenced"}, + {Name: "ownedDisjoining", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedDisjoining", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Disjoining", Many: true, Derived: true, Subsets: []string{"Element::ownedRelationship"}, Opposite: "Disjoining::owningType"}, + {Name: "ownedEndFeature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedEndFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::endFeature", "Type::ownedFeature"}, Opposite: "Feature::endOwningType"}, + {Name: "ownedFeature", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedFeature", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Feature", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::ownedMember"}, Opposite: "Feature::owningType"}, + {Name: "ownedFeatureMembership", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedFeatureMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FeatureMembership", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::ownedMembership", "Type::featureMembership"}, Opposite: "FeatureMembership::owningType"}, + {Name: "ownedIntersecting", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedIntersecting", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Intersecting", Many: true, Ordered: true, Derived: true, Subsets: []string{"Element::ownedRelationship"}, Opposite: "Intersecting::typeIntersected"}, + {Name: "ownedSpecialization", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedSpecialization", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Specialization", Many: true, Ordered: true, Derived: true, Subsets: []string{"Element::ownedRelationship"}, Opposite: "Specialization::owningType"}, + {Name: "ownedUnioning", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_ownedUnioning", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Unioning", Many: true, Ordered: true, Derived: true, Subsets: []string{"Element::ownedRelationship"}, Opposite: "Unioning::typeUnioned"}, + {Name: "unioningType", DefiningClass: "Type", IRI: "https://www.omg.org/spec/SysML#Type_unioningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Many: true, Ordered: true, Derived: true}, + {Name: "typeUnioned", DefiningClass: "Unioning", IRI: "https://www.omg.org/spec/SysML#Unioning_typeUnioned", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Derived: true, Redefines: []string{"Relationship::source"}, Subsets: []string{"Relationship::owningRelatedElement"}, Opposite: "Type::ownedUnioning"}, + {Name: "unioningType", DefiningClass: "Unioning", IRI: "https://www.omg.org/spec/SysML#Unioning_unioningType", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Type", Redefines: []string{"Relationship::target"}}, + {Name: "definition", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_definition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Classifier", Many: true, Ordered: true, Derived: true, Redefines: []string{"Feature::type"}}, + {Name: "directedUsage", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_directedUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::directedFeature", "Usage::usage"}}, + {Name: "isReference", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_isReference", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean", Derived: true}, {Name: "isVariation", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_isVariation", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, - {Name: "nestedAction", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Many: true}, - {Name: "nestedAllocation", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedAllocation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AllocationUsage", Many: true}, - {Name: "nestedAnalysisCase", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedAnalysisCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AnalysisCaseUsage", Many: true}, - {Name: "nestedAttribute", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedAttribute", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AttributeUsage", Many: true}, - {Name: "nestedCalculation", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedCalculation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CalculationUsage", Many: true}, - {Name: "nestedCase", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CaseUsage", Many: true}, - {Name: "nestedConcern", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage", Many: true}, - {Name: "nestedConnection", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedConnection", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConnectorAsUsage", Many: true}, - {Name: "nestedConstraint", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true}, - {Name: "nestedEnumeration", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedEnumeration", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#EnumerationUsage", Many: true}, - {Name: "nestedFlow", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedFlow", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FlowConnectionUsage", Many: true}, - {Name: "nestedInterface", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedInterface", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#InterfaceUsage", Many: true}, - {Name: "nestedItem", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedItem", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ItemUsage", Many: true}, - {Name: "nestedMetadata", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedMetadata", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#MetadataUsage", Many: true}, - {Name: "nestedOccurrence", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedOccurrence", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#OccurrenceUsage", Many: true}, - {Name: "nestedPart", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedPart", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true}, - {Name: "nestedPort", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedPort", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortUsage", Many: true}, - {Name: "nestedReference", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedReference", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ReferenceUsage", Many: true}, - {Name: "nestedRendering", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage", Many: true}, - {Name: "nestedRequirement", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Many: true}, - {Name: "nestedState", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedState", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#StateUsage", Many: true}, - {Name: "nestedTransition", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedTransition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#TransitionUsage", Many: true}, - {Name: "nestedUsage", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true}, - {Name: "nestedUseCase", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedUseCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseUsage", Many: true}, - {Name: "nestedVerificationCase", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedVerificationCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#VerificationCaseUsage", Many: true}, - {Name: "nestedView", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedView", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewUsage", Many: true}, - {Name: "nestedViewpoint", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedViewpoint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewpointUsage", Many: true}, - {Name: "owningDefinition", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_owningDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Definition"}, - {Name: "owningUsage", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_owningUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage"}, - {Name: "usage", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_usage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true}, - {Name: "variant", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_variant", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true}, - {Name: "variantMembership", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_variantMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#VariantMembership", Many: true}, - {Name: "includedUseCase", DefiningClass: "UseCaseDefinition", IRI: "https://www.omg.org/spec/SysML#UseCaseDefinition_includedUseCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseUsage", Many: true}, - {Name: "includedUseCase", DefiningClass: "UseCaseUsage", IRI: "https://www.omg.org/spec/SysML#UseCaseUsage_includedUseCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseUsage", Many: true}, - {Name: "useCaseDefinition", DefiningClass: "UseCaseUsage", IRI: "https://www.omg.org/spec/SysML#UseCaseUsage_useCaseDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseDefinition"}, - {Name: "ownedVariantUsage", DefiningClass: "VariantMembership", IRI: "https://www.omg.org/spec/SysML#VariantMembership_ownedVariantUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage"}, - {Name: "verifiedRequirement", DefiningClass: "VerificationCaseDefinition", IRI: "https://www.omg.org/spec/SysML#VerificationCaseDefinition_verifiedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Many: true}, - {Name: "verificationCaseDefinition", DefiningClass: "VerificationCaseUsage", IRI: "https://www.omg.org/spec/SysML#VerificationCaseUsage_verificationCaseDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#VerificationCaseDefinition"}, - {Name: "verifiedRequirement", DefiningClass: "VerificationCaseUsage", IRI: "https://www.omg.org/spec/SysML#VerificationCaseUsage_verifiedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Many: true}, - {Name: "satisfiedViewpoint", DefiningClass: "ViewDefinition", IRI: "https://www.omg.org/spec/SysML#ViewDefinition_satisfiedViewpoint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewpointUsage", Many: true}, - {Name: "view", DefiningClass: "ViewDefinition", IRI: "https://www.omg.org/spec/SysML#ViewDefinition_view", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewUsage", Many: true}, - {Name: "viewCondition", DefiningClass: "ViewDefinition", IRI: "https://www.omg.org/spec/SysML#ViewDefinition_viewCondition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true}, - {Name: "viewRendering", DefiningClass: "ViewDefinition", IRI: "https://www.omg.org/spec/SysML#ViewDefinition_viewRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage"}, - {Name: "ownedRendering", DefiningClass: "ViewRenderingMembership", IRI: "https://www.omg.org/spec/SysML#ViewRenderingMembership_ownedRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage"}, - {Name: "referencedRendering", DefiningClass: "ViewRenderingMembership", IRI: "https://www.omg.org/spec/SysML#ViewRenderingMembership_referencedRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage"}, - {Name: "exposedElement", DefiningClass: "ViewUsage", IRI: "https://www.omg.org/spec/SysML#ViewUsage_exposedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true}, - {Name: "satisfiedViewpoint", DefiningClass: "ViewUsage", IRI: "https://www.omg.org/spec/SysML#ViewUsage_satisfiedViewpoint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewpointUsage", Many: true}, - {Name: "viewCondition", DefiningClass: "ViewUsage", IRI: "https://www.omg.org/spec/SysML#ViewUsage_viewCondition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true}, - {Name: "viewDefinition", DefiningClass: "ViewUsage", IRI: "https://www.omg.org/spec/SysML#ViewUsage_viewDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewDefinition"}, - {Name: "viewRendering", DefiningClass: "ViewUsage", IRI: "https://www.omg.org/spec/SysML#ViewUsage_viewRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage"}, - {Name: "viewpointStakeholder", DefiningClass: "ViewpointDefinition", IRI: "https://www.omg.org/spec/SysML#ViewpointDefinition_viewpointStakeholder", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true}, - {Name: "viewpointDefinition", DefiningClass: "ViewpointUsage", IRI: "https://www.omg.org/spec/SysML#ViewpointUsage_viewpointDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewpointDefinition"}, - {Name: "viewpointStakeholder", DefiningClass: "ViewpointUsage", IRI: "https://www.omg.org/spec/SysML#ViewpointUsage_viewpointStakeholder", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true}, - {Name: "untilArgument", DefiningClass: "WhileLoopActionUsage", IRI: "https://www.omg.org/spec/SysML#WhileLoopActionUsage_untilArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, - {Name: "whileArgument", DefiningClass: "WhileLoopActionUsage", IRI: "https://www.omg.org/spec/SysML#WhileLoopActionUsage_whileArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression"}, + {Name: "mayTimeVary", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_mayTimeVary", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean", Derived: true, Redefines: []string{"Feature::isVariable"}}, + {Name: "nestedAction", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedAction", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ActionUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedOccurrence"}}, + {Name: "nestedAllocation", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedAllocation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AllocationUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedConnection"}}, + {Name: "nestedAnalysisCase", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedAnalysisCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AnalysisCaseUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedCase"}}, + {Name: "nestedAttribute", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedAttribute", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#AttributeUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedUsage"}}, + {Name: "nestedCalculation", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedCalculation", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CalculationUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedAction"}}, + {Name: "nestedCase", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#CaseUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedCalculation"}}, + {Name: "nestedConcern", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedConcern", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConcernUsage", Many: true, Derived: true, Subsets: []string{"Usage::nestedRequirement"}}, + {Name: "nestedConnection", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedConnection", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConnectorAsUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedUsage"}}, + {Name: "nestedConstraint", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedConstraint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ConstraintUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedOccurrence"}}, + {Name: "nestedEnumeration", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedEnumeration", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#EnumerationUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedAttribute"}}, + {Name: "nestedFlow", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedFlow", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#FlowUsage", Many: true, Derived: true, Subsets: []string{"Usage::nestedConnection"}}, + {Name: "nestedInterface", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedInterface", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#InterfaceUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedConnection"}}, + {Name: "nestedItem", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedItem", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ItemUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedOccurrence"}}, + {Name: "nestedMetadata", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedMetadata", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#MetadataUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedItem"}}, + {Name: "nestedOccurrence", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedOccurrence", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#OccurrenceUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedUsage"}}, + {Name: "nestedPart", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedPart", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedItem"}}, + {Name: "nestedPort", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedPort", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PortUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedUsage"}}, + {Name: "nestedReference", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedReference", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ReferenceUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedUsage"}}, + {Name: "nestedRendering", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedPart"}}, + {Name: "nestedRequirement", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedConstraint"}}, + {Name: "nestedState", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedState", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#StateUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedAction"}}, + {Name: "nestedTransition", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedTransition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#TransitionUsage", Many: true, Derived: true, Subsets: []string{"Usage::nestedUsage"}}, + {Name: "nestedUsage", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::ownedFeature", "Usage::usage"}, Opposite: "Usage::owningUsage"}, + {Name: "nestedUseCase", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedUseCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedCase"}}, + {Name: "nestedVerificationCase", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedVerificationCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#VerificationCaseUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedCase"}}, + {Name: "nestedView", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedView", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedPart"}}, + {Name: "nestedViewpoint", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_nestedViewpoint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewpointUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedRequirement"}}, + {Name: "owningDefinition", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_owningDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Definition", Derived: true, Subsets: []string{"Feature::owningType"}, Opposite: "Definition::ownedUsage"}, + {Name: "owningUsage", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_owningUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Derived: true, Subsets: []string{"Feature::owningType"}, Opposite: "Usage::nestedUsage"}, + {Name: "usage", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_usage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Type::feature"}}, + {Name: "variant", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_variant", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Many: true, Derived: true, Subsets: []string{"Namespace::ownedMember"}}, + {Name: "variantMembership", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_variantMembership", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#VariantMembership", Many: true, Derived: true, Subsets: []string{"Namespace::ownedMembership"}}, + {Name: "includedUseCase", DefiningClass: "UseCaseDefinition", IRI: "https://www.omg.org/spec/SysML#UseCaseDefinition_includedUseCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseUsage", Many: true, Ordered: true, Derived: true}, + {Name: "includedUseCase", DefiningClass: "UseCaseUsage", IRI: "https://www.omg.org/spec/SysML#UseCaseUsage_includedUseCase", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseUsage", Many: true, Ordered: true, Derived: true}, + {Name: "useCaseDefinition", DefiningClass: "UseCaseUsage", IRI: "https://www.omg.org/spec/SysML#UseCaseUsage_useCaseDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#UseCaseDefinition", Derived: true, Redefines: []string{"CaseUsage::caseDefinition"}}, + {Name: "ownedVariantUsage", DefiningClass: "VariantMembership", IRI: "https://www.omg.org/spec/SysML#VariantMembership_ownedVariantUsage", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Usage", Derived: true, Redefines: []string{"OwningMembership::ownedMemberElement"}}, + {Name: "verifiedRequirement", DefiningClass: "VerificationCaseDefinition", IRI: "https://www.omg.org/spec/SysML#VerificationCaseDefinition_verifiedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Many: true, Ordered: true, Derived: true}, + {Name: "verificationCaseDefinition", DefiningClass: "VerificationCaseUsage", IRI: "https://www.omg.org/spec/SysML#VerificationCaseUsage_verificationCaseDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#VerificationCaseDefinition", Derived: true, Subsets: []string{"CaseUsage::caseDefinition"}}, + {Name: "verifiedRequirement", DefiningClass: "VerificationCaseUsage", IRI: "https://www.omg.org/spec/SysML#VerificationCaseUsage_verifiedRequirement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RequirementUsage", Many: true, Ordered: true, Derived: true}, + {Name: "satisfiedViewpoint", DefiningClass: "ViewDefinition", IRI: "https://www.omg.org/spec/SysML#ViewDefinition_satisfiedViewpoint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewpointUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::ownedRequirement"}}, + {Name: "view", DefiningClass: "ViewDefinition", IRI: "https://www.omg.org/spec/SysML#ViewDefinition_view", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Definition::usage"}}, + {Name: "viewCondition", DefiningClass: "ViewDefinition", IRI: "https://www.omg.org/spec/SysML#ViewDefinition_viewCondition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::ownedMember"}}, + {Name: "viewRendering", DefiningClass: "ViewDefinition", IRI: "https://www.omg.org/spec/SysML#ViewDefinition_viewRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage", Derived: true}, + {Name: "ownedRendering", DefiningClass: "ViewRenderingMembership", IRI: "https://www.omg.org/spec/SysML#ViewRenderingMembership_ownedRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage", Derived: true, Redefines: []string{"FeatureMembership::ownedMemberFeature"}}, + {Name: "referencedRendering", DefiningClass: "ViewRenderingMembership", IRI: "https://www.omg.org/spec/SysML#ViewRenderingMembership_referencedRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage", Derived: true}, + {Name: "exposedElement", DefiningClass: "ViewUsage", IRI: "https://www.omg.org/spec/SysML#ViewUsage_exposedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::member"}}, + {Name: "satisfiedViewpoint", DefiningClass: "ViewUsage", IRI: "https://www.omg.org/spec/SysML#ViewUsage_satisfiedViewpoint", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewpointUsage", Many: true, Ordered: true, Derived: true, Subsets: []string{"Usage::nestedRequirement"}}, + {Name: "viewCondition", DefiningClass: "ViewUsage", IRI: "https://www.omg.org/spec/SysML#ViewUsage_viewCondition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Many: true, Ordered: true, Derived: true, Subsets: []string{"Namespace::ownedMember"}}, + {Name: "viewDefinition", DefiningClass: "ViewUsage", IRI: "https://www.omg.org/spec/SysML#ViewUsage_viewDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewDefinition", Derived: true, Redefines: []string{"PartUsage::partDefinition"}}, + {Name: "viewRendering", DefiningClass: "ViewUsage", IRI: "https://www.omg.org/spec/SysML#ViewUsage_viewRendering", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#RenderingUsage", Derived: true}, + {Name: "viewpointStakeholder", DefiningClass: "ViewpointDefinition", IRI: "https://www.omg.org/spec/SysML#ViewpointDefinition_viewpointStakeholder", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true, Ordered: true, Derived: true}, + {Name: "viewpointDefinition", DefiningClass: "ViewpointUsage", IRI: "https://www.omg.org/spec/SysML#ViewpointUsage_viewpointDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#ViewpointDefinition", Derived: true, Redefines: []string{"RequirementUsage::requirementDefinition"}}, + {Name: "viewpointStakeholder", DefiningClass: "ViewpointUsage", IRI: "https://www.omg.org/spec/SysML#ViewpointUsage_viewpointStakeholder", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true, Ordered: true, Derived: true}, + {Name: "untilArgument", DefiningClass: "WhileLoopActionUsage", IRI: "https://www.omg.org/spec/SysML#WhileLoopActionUsage_untilArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, + {Name: "whileArgument", DefiningClass: "WhileLoopActionUsage", IRI: "https://www.omg.org/spec/SysML#WhileLoopActionUsage_whileArgument", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Expression", Derived: true}, +} + +// enumerations holds every EEnum and its literals in declaration order, ordered by name. +var enumerations = []Enumeration{ + {Name: "FeatureDirectionKind", Literals: []string{"in", "inout", "out"}}, + {Name: "PortionKind", Literals: []string{"timeslice", "snapshot"}}, + {Name: "RequirementConstraintKind", Literals: []string{"assumption", "requirement"}}, + {Name: "StateSubactionKind", Literals: []string{"entry", "do", "exit"}}, + {Name: "TransitionFeatureKind", Literals: []string{"trigger", "guard", "effect"}}, + {Name: "TriggerKind", Literals: []string{"when", "at", "after"}}, + {Name: "VisibilityKind", Literals: []string{"private", "protected", "public"}}, } -// classes holds every owl:Class the ontology declares with its named -// rdfs:subClassOf parents, ordered by name. +// classes holds every EClass the metamodel declares with its eSuperTypes, ordered by name. var classes = []Class{ {Name: "AcceptActionUsage", Parents: []string{"ActionUsage"}}, {Name: "ActionDefinition", Parents: []string{"Behavior", "OccurrenceDefinition"}}, @@ -472,10 +489,12 @@ var classes = []Class{ {Name: "ConnectionDefinition", Parents: []string{"AssociationStructure", "PartDefinition"}}, {Name: "ConnectionUsage", Parents: []string{"ConnectorAsUsage", "PartUsage"}}, {Name: "Connector", Parents: []string{"Feature", "Relationship"}}, - {Name: "ConnectorAsUsage", Parents: []string{"Connector", "Usage"}}, + {Name: "ConnectorAsUsage", Abstract: true, Parents: []string{"Connector", "Usage"}}, {Name: "ConstraintDefinition", Parents: []string{"OccurrenceDefinition", "Predicate"}}, {Name: "ConstraintUsage", Parents: []string{"BooleanExpression", "OccurrenceUsage"}}, - {Name: "ControlNode", Parents: []string{"ActionUsage"}}, + {Name: "ConstructorExpression", Parents: []string{"InstantiationExpression"}}, + {Name: "ControlNode", Abstract: true, Parents: []string{"ActionUsage"}}, + {Name: "CrossSubsetting", Parents: []string{"Subsetting"}}, {Name: "DataType", Parents: []string{"Classifier"}}, {Name: "DecisionNode", Parents: []string{"ControlNode"}}, {Name: "Definition", Parents: []string{"Classifier"}}, @@ -483,54 +502,53 @@ var classes = []Class{ {Name: "Differencing", Parents: []string{"Relationship"}}, {Name: "Disjoining", Parents: []string{"Relationship"}}, {Name: "Documentation", Parents: []string{"Comment"}}, - {Name: "Element"}, + {Name: "Element", Abstract: true}, {Name: "ElementFilterMembership", Parents: []string{"OwningMembership"}}, {Name: "EndFeatureMembership", Parents: []string{"FeatureMembership"}}, {Name: "EnumerationDefinition", Parents: []string{"AttributeDefinition"}}, {Name: "EnumerationUsage", Parents: []string{"AttributeUsage"}}, {Name: "EventOccurrenceUsage", Parents: []string{"OccurrenceUsage"}}, {Name: "ExhibitStateUsage", Parents: []string{"PerformActionUsage", "StateUsage"}}, - {Name: "Expose", Parents: []string{"Import"}}, + {Name: "Expose", Abstract: true, Parents: []string{"Import"}}, {Name: "Expression", Parents: []string{"Step"}}, {Name: "Feature", Parents: []string{"Type"}}, {Name: "FeatureChainExpression", Parents: []string{"OperatorExpression"}}, {Name: "FeatureChaining", Parents: []string{"Relationship"}}, {Name: "FeatureInverting", Parents: []string{"Relationship"}}, - {Name: "FeatureMembership", Parents: []string{"Featuring", "OwningMembership"}}, + {Name: "FeatureMembership", Parents: []string{"OwningMembership"}}, {Name: "FeatureReferenceExpression", Parents: []string{"Expression"}}, {Name: "FeatureTyping", Parents: []string{"Specialization"}}, {Name: "FeatureValue", Parents: []string{"OwningMembership"}}, - {Name: "Featuring", Parents: []string{"Relationship"}}, - {Name: "FlowConnectionDefinition", Parents: []string{"ActionDefinition", "ConnectionDefinition", "Interaction"}}, - {Name: "FlowConnectionUsage", Parents: []string{"ActionUsage", "ConnectionUsage", "ItemFlow"}}, + {Name: "Flow", Parents: []string{"Connector", "Step"}}, + {Name: "FlowDefinition", Parents: []string{"ActionDefinition", "Interaction"}}, + {Name: "FlowEnd", Parents: []string{"Feature"}}, + {Name: "FlowUsage", Parents: []string{"ActionUsage", "ConnectorAsUsage", "Flow"}}, {Name: "ForLoopActionUsage", Parents: []string{"LoopActionUsage"}}, {Name: "ForkNode", Parents: []string{"ControlNode"}}, {Name: "FramedConcernMembership", Parents: []string{"RequirementConstraintMembership"}}, {Name: "Function", Parents: []string{"Behavior"}}, {Name: "IfActionUsage", Parents: []string{"ActionUsage"}}, - {Name: "Import", Parents: []string{"Relationship"}}, + {Name: "Import", Abstract: true, Parents: []string{"Relationship"}}, {Name: "IncludeUseCaseUsage", Parents: []string{"PerformActionUsage", "UseCaseUsage"}}, + {Name: "IndexExpression", Parents: []string{"OperatorExpression"}}, + {Name: "InstantiationExpression", Abstract: true, Parents: []string{"Expression"}}, {Name: "Interaction", Parents: []string{"Association", "Behavior"}}, {Name: "InterfaceDefinition", Parents: []string{"ConnectionDefinition"}}, {Name: "InterfaceUsage", Parents: []string{"ConnectionUsage"}}, {Name: "Intersecting", Parents: []string{"Relationship"}}, {Name: "Invariant", Parents: []string{"BooleanExpression"}}, - {Name: "InvocationExpression", Parents: []string{"Expression"}}, + {Name: "InvocationExpression", Parents: []string{"InstantiationExpression"}}, {Name: "ItemDefinition", Parents: []string{"OccurrenceDefinition", "Structure"}}, - {Name: "ItemFeature", Parents: []string{"Feature"}}, - {Name: "ItemFlow", Parents: []string{"Connector", "Step"}}, - {Name: "ItemFlowEnd", Parents: []string{"Feature"}}, {Name: "ItemUsage", Parents: []string{"OccurrenceUsage"}}, {Name: "JoinNode", Parents: []string{"ControlNode"}}, {Name: "LibraryPackage", Parents: []string{"Package"}}, - {Name: "LifeClass", Parents: []string{"Class"}}, {Name: "LiteralBoolean", Parents: []string{"LiteralExpression"}}, {Name: "LiteralExpression", Parents: []string{"Expression"}}, {Name: "LiteralInfinity", Parents: []string{"LiteralExpression"}}, {Name: "LiteralInteger", Parents: []string{"LiteralExpression"}}, {Name: "LiteralRational", Parents: []string{"LiteralExpression"}}, {Name: "LiteralString", Parents: []string{"LiteralExpression"}}, - {Name: "LoopActionUsage", Parents: []string{"ActionUsage"}}, + {Name: "LoopActionUsage", Abstract: true, Parents: []string{"ActionUsage"}}, {Name: "Membership", Parents: []string{"Relationship"}}, {Name: "MembershipExpose", Parents: []string{"Expose", "MembershipImport"}}, {Name: "MembershipImport", Parents: []string{"Import"}}, @@ -555,6 +573,7 @@ var classes = []Class{ {Name: "ParameterMembership", Parents: []string{"FeatureMembership"}}, {Name: "PartDefinition", Parents: []string{"ItemDefinition"}}, {Name: "PartUsage", Parents: []string{"ItemUsage"}}, + {Name: "PayloadFeature", Parents: []string{"Feature"}}, {Name: "PerformActionUsage", Parents: []string{"ActionUsage", "EventOccurrenceUsage"}}, {Name: "PortConjugation", Parents: []string{"Conjugation"}}, {Name: "PortDefinition", Parents: []string{"OccurrenceDefinition", "Structure"}}, @@ -563,7 +582,7 @@ var classes = []Class{ {Name: "Redefinition", Parents: []string{"Subsetting"}}, {Name: "ReferenceSubsetting", Parents: []string{"Subsetting"}}, {Name: "ReferenceUsage", Parents: []string{"Usage"}}, - {Name: "Relationship", Parents: []string{"Element"}}, + {Name: "Relationship", Abstract: true, Parents: []string{"Element"}}, {Name: "RenderingDefinition", Parents: []string{"PartDefinition"}}, {Name: "RenderingUsage", Parents: []string{"PartUsage"}}, {Name: "RequirementConstraintMembership", Parents: []string{"FeatureMembership"}}, @@ -587,14 +606,15 @@ var classes = []Class{ {Name: "Subsetting", Parents: []string{"Specialization"}}, {Name: "Succession", Parents: []string{"Connector"}}, {Name: "SuccessionAsUsage", Parents: []string{"ConnectorAsUsage", "Succession"}}, - {Name: "SuccessionFlowConnectionUsage", Parents: []string{"FlowConnectionUsage", "SuccessionItemFlow"}}, - {Name: "SuccessionItemFlow", Parents: []string{"ItemFlow", "Succession"}}, + {Name: "SuccessionFlow", Parents: []string{"Flow", "Succession"}}, + {Name: "SuccessionFlowUsage", Parents: []string{"FlowUsage", "SuccessionFlow"}}, + {Name: "TerminateActionUsage", Parents: []string{"ActionUsage"}}, {Name: "TextualRepresentation", Parents: []string{"AnnotatingElement"}}, {Name: "TransitionFeatureMembership", Parents: []string{"FeatureMembership"}}, {Name: "TransitionUsage", Parents: []string{"ActionUsage"}}, {Name: "TriggerInvocationExpression", Parents: []string{"InvocationExpression"}}, {Name: "Type", Parents: []string{"Namespace"}}, - {Name: "TypeFeaturing", Parents: []string{"Featuring"}}, + {Name: "TypeFeaturing", Parents: []string{"Relationship"}}, {Name: "Unioning", Parents: []string{"Relationship"}}, {Name: "Usage", Parents: []string{"Feature"}}, {Name: "UseCaseDefinition", Parents: []string{"CaseDefinition"}}, diff --git a/internal/translate/rdf/ontology/validate.go b/internal/translate/rdf/ontology/validate.go index 67d69bf699..16efc3d28b 100644 --- a/internal/translate/rdf/ontology/validate.go +++ b/internal/translate/rdf/ontology/validate.go @@ -13,6 +13,9 @@ type ViolationKind string const ( // UnknownClass is an rdf:type the ontology declares no owl:Class for. UnknownClass ViolationKind = "unknown-class" + // AbstractClass is an rdf:type the metamodel declares abstract, which no + // element instantiates directly. + AbstractClass ViolationKind = "abstract-class" // UntypedSubject carries SysML properties with no rdf:type, which leaves // their domain uncheckable. UntypedSubject ViolationKind = "untyped-subject" @@ -57,8 +60,7 @@ const missing = "-" // Check reports every way the triples of g disagree with the ontology. Only // SysML-namespace predicates are checked; the RDF vocabulary and this tool's own -// extension namespace are out of the ontology's scope. The ontology records no -// abstractness, so an abstract metaclass is not a violation here. +// extension namespace are out of the ontology's scope. func Check(g *rdf.Graph) []Violation { var out []Violation hasSysMLProperty := make(map[rdf.Term]bool) @@ -68,8 +70,10 @@ func Check(g *rdf.Graph) []Violation { } } declared := make(map[rdf.Term]bool) + types := make(map[rdf.Term]string) for _, subject := range g.Subjects() { - typeIRI := g.Type(subject) + typeIRI := subjectType(g, subject) + types[subject] = typeIRI if typeIRI == "" { if hasSysMLProperty[subject] { out = append(out, Violation{ @@ -79,8 +83,14 @@ func Check(g *rdf.Graph) []Violation { } continue } - if _, ok := LookupClass(classNameOf(typeIRI)); ok { + if class, ok := LookupClass(classNameOf(typeIRI)); ok { declared[subject] = true + if class.Abstract { + out = append(out, Violation{ + Kind: AbstractClass, Class: class.Name, Property: missing, Subject: subject.Value, + Detail: fmt.Sprintf("rdf:type %s is abstract in the metamodel", typeIRI), + }) + } continue } out = append(out, Violation{ @@ -92,7 +102,7 @@ func Check(g *rdf.Graph) []Violation { if !strings.HasPrefix(triple.Predicate.Value, rdf.SysML) { continue } - class := classNameOf(g.Type(triple.Subject)) + class := classNameOf(types[triple.Subject]) if class == "" { continue // already reported as an untyped subject } @@ -158,6 +168,47 @@ func objectMatchesKind(kind PropertyKind, object rdf.Term) bool { // classNameOf returns the local name of an rdf:type IRI, or "" when there is // none. An IRI outside the SysML namespace is kept whole, to stay recognizable. +// MostSpecific picks the class IRI among those stated that every other is a +// superclass of, reporting false when there is none. +func MostSpecific(classIRIs []string) (string, bool) { + for _, class := range classIRIs { + specific := true + for _, other := range classIRIs { + if !subclassOf(class, other) { + specific = false + break + } + } + if specific { + return class, true + } + } + return "", false +} + +// subclassOf reports whether the class iri is ancestor or a subclass of it in +// the SysML ontology; a class outside the SysML namespace has no superclass. +func subclassOf(class, ancestor string) bool { + return class == ancestor || strings.HasPrefix(class, rdf.SysML) && strings.HasPrefix(ancestor, rdf.SysML) && + IsAncestorOrSelf(rdf.LocalName(class), rdf.LocalName(ancestor)) +} + +// subjectType returns the class subject is read as: its most specific stated +// rdf:type, or the first one when the stated types are unrelated. +func subjectType(g *rdf.Graph, subject rdf.Term) string { + var stated []string + for _, object := range g.Objects(subject, rdf.RDFType) { + stated = append(stated, object.Value) + } + if len(stated) == 0 { + return "" + } + if class, ok := MostSpecific(stated); ok { + return class + } + return stated[0] +} + func classNameOf(typeIRI string) string { if typeIRI == "" { return "" diff --git a/mkdocs.yml b/mkdocs.yml index 588571c868..a669f26ed1 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -218,6 +218,7 @@ nav: - Errors: clients/python/errors.md - The service: clients/python/service.md - Typed classes: clients/python/typed-classes.md + - Metamodel classes and JSON: clients/python/metamodel.md - Node: clients/node.md - Java: clients/java.md - Rust: clients/rust.md diff --git a/scripts/download-pilot-metamodel.sh b/scripts/download-pilot-metamodel.sh new file mode 100755 index 0000000000..aa4389d419 --- /dev/null +++ b/scripts/download-pilot-metamodel.sh @@ -0,0 +1,25 @@ +#!/usr/bin/env bash +# Download the OMG SysML v2 metamodel, the pilot implementation's +# org.omg.sysml/model/SysML.ecore, into build/pilot-metamodel/, for +# tools/gen/ontology, which generates internal/translate/rdf/ontology/table.go +# from it and, with -check, fails when the committed table has drifted. +# +# The metamodel is not vendored: it belongs to the OMG pilot implementation and +# is licensed there. It is pinned by scripts/pilot-pin.sh like every other pilot +# input, so the table moves with the pilot release the rest of the tree is +# measured against. The download records that pin in a .pilot-pin stamp, which +# the generator writes into the table's header, and is re-fetched when the stamp +# does not match. +set -euo pipefail + +# shellcheck source=scripts/pilot-pin.sh +. "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/pilot-pin.sh" + +repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +target="$repo_root/build/pilot-metamodel" + +PILOT_FETCH_GLOBS=('SysML.ecore') +pilot_fetch_subtrees "org.omg.sysml/model:$target" + +echo "Regenerate or check the metamodel table against it with:" +echo " go run -C tools ./gen/ontology [-check]" diff --git a/tests/export/cross_feature_test.go b/tests/export/cross_feature_test.go index 9130f4bfc9..ca5dcb4647 100644 --- a/tests/export/cross_feature_test.go +++ b/tests/export/cross_feature_test.go @@ -301,19 +301,19 @@ func TestCrossFeatureOrderingComesBackFromTheGraphAlone(t *testing.T) { ` g := turtleOf(t, "crossing", sysml) elmt := func(name string) string { return rdf.ElementIRI(name).Value } - for _, flag := range []struct{ end, cross, property string }{ - {"Crossing::C::x", "Crossing::C::x::x1", "isOrdered"}, - {"Crossing::C::y", "Crossing::C::y::@0", "isOrdered"}, - {"Crossing::C::y", "Crossing::C::y::@0", "isNonunique"}, - {"Crossing::C::z", "Crossing::C::z::@0", "isNonunique"}, - {"Crossing::C::w", "Crossing::C::w::@0", "isNonunique"}, + for _, flag := range []struct{ end, cross, property, value string }{ + {"Crossing::C::x", "Crossing::C::x::x1", "isOrdered", "true"}, + {"Crossing::C::y", "Crossing::C::y::@0", "isOrdered", "true"}, + {"Crossing::C::y", "Crossing::C::y::@0", "isUnique", "false"}, + {"Crossing::C::z", "Crossing::C::z::@0", "isUnique", "false"}, + {"Crossing::C::w", "Crossing::C::w::@0", "isUnique", "false"}, } { - wantLexical(t, g, elmt(flag.cross), rdf.SysML+flag.property, "true") + wantLexical(t, g, elmt(flag.cross), rdf.SysML+flag.property, flag.value) if g.HasProperty(iri(elmt(flag.end)), rdf.SysML+flag.property) { t.Errorf("the end <%s> took its cross feature's %s", flag.end, flag.property) } } - if g.HasProperty(iri(elmt("Crossing::C::x::x1")), rdf.SysML+"isNonunique") { + if g.HasProperty(iri(elmt("Crossing::C::x::x1")), rdf.SysML+"isUnique") { t.Errorf("the ordered cross feature x1 is not nonunique") } if back := toNotation(t, withoutTriples(t, idTurtle(t, sysml), "sysx:sourceText")); back != sysml { diff --git a/tests/export/testdata/convert/action_nodes.golden.ttl b/tests/export/testdata/convert/action_nodes.golden.ttl index 8e7fb4eb5f..c6a20cd8c0 100644 --- a/tests/export/testdata/convert/action_nodes.golden.ttl +++ b/tests/export/testdata/convert/action_nodes.golden.ttl @@ -164,15 +164,15 @@ elmt:ActionNodes__Drive sysml:ownedMember elmt:ActionNodes__Drive__speed, elmt:ActionNodes__Drive__log, elmt:ActionNodes__Drive__antenna, elmt:ActionNodes__Drive__Stop, elmt:ActionNodes__Drive__brake, elmt:ActionNodes__Drive__split, elmt:ActionNodes__Drive__sync, elmt:ActionNodes__Drive__gather, elmt:ActionNodes__Drive__pick, elmt:ActionNodes__Drive___4010, elmt:ActionNodes__Drive__Brake, elmt:ActionNodes__Drive___4012, elmt:ActionNodes__Drive___4013, elmt:ActionNodes__Drive___4014, elmt:ActionNodes__Drive___4015, elmt:ActionNodes__Drive___4016, elmt:ActionNodes__Drive___4017, elmt:ActionNodes__Drive___4019, elmt:ActionNodes__Drive___4020 ; sysml:ownedMembership elmt:ActionNodes__Drive__speed_om, elmt:ActionNodes__Drive__log_om, elmt:ActionNodes__Drive__antenna_om, elmt:ActionNodes__Drive__Stop_om, elmt:ActionNodes__Drive___404, elmt:ActionNodes__Drive__brake_om, elmt:ActionNodes__Drive__split_om, elmt:ActionNodes__Drive__sync_om, elmt:ActionNodes__Drive__gather_om, elmt:ActionNodes__Drive__pick_om, elmt:ActionNodes__Drive___4010_om, elmt:ActionNodes__Drive__Brake_om, elmt:ActionNodes__Drive___4012_om, elmt:ActionNodes__Drive___4013_om, elmt:ActionNodes__Drive___4014_om, elmt:ActionNodes__Drive___4015_om, elmt:ActionNodes__Drive___4016_om, elmt:ActionNodes__Drive___4017_om, elmt:ActionNodes__Drive___4018, elmt:ActionNodes__Drive___4019_om, elmt:ActionNodes__Drive___4020_om ; sysml:ownedRelationship elmt:ActionNodes__Drive__speed_om, elmt:ActionNodes__Drive__log_om, elmt:ActionNodes__Drive__antenna_om, elmt:ActionNodes__Drive__Stop_om, elmt:ActionNodes__Drive___404, elmt:ActionNodes__Drive__brake_om, elmt:ActionNodes__Drive__split_om, elmt:ActionNodes__Drive__sync_om, elmt:ActionNodes__Drive__gather_om, elmt:ActionNodes__Drive__pick_om, elmt:ActionNodes__Drive___4010_om, elmt:ActionNodes__Drive__Brake_om, elmt:ActionNodes__Drive___4012_om, elmt:ActionNodes__Drive___4013_om, elmt:ActionNodes__Drive___4014_om, elmt:ActionNodes__Drive___4015_om, elmt:ActionNodes__Drive___4016_om, elmt:ActionNodes__Drive___4017_om, elmt:ActionNodes__Drive___4018, elmt:ActionNodes__Drive___4019_om, elmt:ActionNodes__Drive___4020_om ; - sysml:ownedFeature elmt:ActionNodes__Drive__speed, elmt:ActionNodes__Drive__log, elmt:ActionNodes__Drive__antenna, elmt:ActionNodes__Drive__brake, elmt:ActionNodes__Drive__split, elmt:ActionNodes__Drive__sync, elmt:ActionNodes__Drive__gather, elmt:ActionNodes__Drive__pick, elmt:ActionNodes__Drive___4010, elmt:ActionNodes__Drive__Brake, elmt:ActionNodes__Drive___4012, elmt:ActionNodes__Drive___4013, elmt:ActionNodes__Drive___4014, elmt:ActionNodes__Drive___4015, elmt:ActionNodes__Drive___4019, elmt:ActionNodes__Drive___4020 ; - sysml:ownedFeatureMembership elmt:ActionNodes__Drive__speed_om, elmt:ActionNodes__Drive__log_om, elmt:ActionNodes__Drive__antenna_om, elmt:ActionNodes__Drive__brake_om, elmt:ActionNodes__Drive__split_om, elmt:ActionNodes__Drive__sync_om, elmt:ActionNodes__Drive__gather_om, elmt:ActionNodes__Drive__pick_om, elmt:ActionNodes__Drive___4010_om, elmt:ActionNodes__Drive__Brake_om, elmt:ActionNodes__Drive___4012_om, elmt:ActionNodes__Drive___4013_om, elmt:ActionNodes__Drive___4014_om, elmt:ActionNodes__Drive___4015_om, elmt:ActionNodes__Drive___4019_om, elmt:ActionNodes__Drive___4020_om ; + sysml:ownedFeature elmt:ActionNodes__Drive__speed, elmt:ActionNodes__Drive__log, elmt:ActionNodes__Drive__antenna, elmt:ActionNodes__Drive__brake, elmt:ActionNodes__Drive__split, elmt:ActionNodes__Drive__sync, elmt:ActionNodes__Drive__gather, elmt:ActionNodes__Drive__pick, elmt:ActionNodes__Drive___4010, elmt:ActionNodes__Drive__Brake, elmt:ActionNodes__Drive___4012, elmt:ActionNodes__Drive___4013, elmt:ActionNodes__Drive___4014, elmt:ActionNodes__Drive___4015, elmt:ActionNodes__Drive___4016, elmt:ActionNodes__Drive___4017, elmt:ActionNodes__Drive___4019, elmt:ActionNodes__Drive___4020 ; + sysml:ownedFeatureMembership elmt:ActionNodes__Drive__speed_om, elmt:ActionNodes__Drive__log_om, elmt:ActionNodes__Drive__antenna_om, elmt:ActionNodes__Drive__brake_om, elmt:ActionNodes__Drive__split_om, elmt:ActionNodes__Drive__sync_om, elmt:ActionNodes__Drive__gather_om, elmt:ActionNodes__Drive__pick_om, elmt:ActionNodes__Drive___4010_om, elmt:ActionNodes__Drive__Brake_om, elmt:ActionNodes__Drive___4012_om, elmt:ActionNodes__Drive___4013_om, elmt:ActionNodes__Drive___4014_om, elmt:ActionNodes__Drive___4015_om, elmt:ActionNodes__Drive___4016_om, elmt:ActionNodes__Drive___4017_om, elmt:ActionNodes__Drive___4019_om, elmt:ActionNodes__Drive___4020_om ; sysx:sourceText " action def Drive {\n" ; sysx:sourceTail " }\n" ; json:ownedMember "[{\"@id\":\"ActionNodes__Drive__speed\"},{\"@id\":\"ActionNodes__Drive__log\"},{\"@id\":\"ActionNodes__Drive__antenna\"},{\"@id\":\"ActionNodes__Drive__Stop\"},{\"@id\":\"ActionNodes__Drive__brake\"},{\"@id\":\"ActionNodes__Drive__split\"},{\"@id\":\"ActionNodes__Drive__sync\"},{\"@id\":\"ActionNodes__Drive__gather\"},{\"@id\":\"ActionNodes__Drive__pick\"},{\"@id\":\"ActionNodes__Drive___4010\"},{\"@id\":\"ActionNodes__Drive__Brake\"},{\"@id\":\"ActionNodes__Drive___4012\"},{\"@id\":\"ActionNodes__Drive___4013\"},{\"@id\":\"ActionNodes__Drive___4014\"},{\"@id\":\"ActionNodes__Drive___4015\"},{\"@id\":\"ActionNodes__Drive___4016\"},{\"@id\":\"ActionNodes__Drive___4017\"},{\"@id\":\"ActionNodes__Drive___4019\"},{\"@id\":\"ActionNodes__Drive___4020\"}]" ; json:ownedMembership "[{\"@id\":\"ActionNodes__Drive__speed_om\"},{\"@id\":\"ActionNodes__Drive__log_om\"},{\"@id\":\"ActionNodes__Drive__antenna_om\"},{\"@id\":\"ActionNodes__Drive__Stop_om\"},{\"@id\":\"ActionNodes__Drive___404\"},{\"@id\":\"ActionNodes__Drive__brake_om\"},{\"@id\":\"ActionNodes__Drive__split_om\"},{\"@id\":\"ActionNodes__Drive__sync_om\"},{\"@id\":\"ActionNodes__Drive__gather_om\"},{\"@id\":\"ActionNodes__Drive__pick_om\"},{\"@id\":\"ActionNodes__Drive___4010_om\"},{\"@id\":\"ActionNodes__Drive__Brake_om\"},{\"@id\":\"ActionNodes__Drive___4012_om\"},{\"@id\":\"ActionNodes__Drive___4013_om\"},{\"@id\":\"ActionNodes__Drive___4014_om\"},{\"@id\":\"ActionNodes__Drive___4015_om\"},{\"@id\":\"ActionNodes__Drive___4016_om\"},{\"@id\":\"ActionNodes__Drive___4017_om\"},{\"@id\":\"ActionNodes__Drive___4018\"},{\"@id\":\"ActionNodes__Drive___4019_om\"},{\"@id\":\"ActionNodes__Drive___4020_om\"}]" ; json:ownedRelationship "[{\"@id\":\"ActionNodes__Drive__speed_om\"},{\"@id\":\"ActionNodes__Drive__log_om\"},{\"@id\":\"ActionNodes__Drive__antenna_om\"},{\"@id\":\"ActionNodes__Drive__Stop_om\"},{\"@id\":\"ActionNodes__Drive___404\"},{\"@id\":\"ActionNodes__Drive__brake_om\"},{\"@id\":\"ActionNodes__Drive__split_om\"},{\"@id\":\"ActionNodes__Drive__sync_om\"},{\"@id\":\"ActionNodes__Drive__gather_om\"},{\"@id\":\"ActionNodes__Drive__pick_om\"},{\"@id\":\"ActionNodes__Drive___4010_om\"},{\"@id\":\"ActionNodes__Drive__Brake_om\"},{\"@id\":\"ActionNodes__Drive___4012_om\"},{\"@id\":\"ActionNodes__Drive___4013_om\"},{\"@id\":\"ActionNodes__Drive___4014_om\"},{\"@id\":\"ActionNodes__Drive___4015_om\"},{\"@id\":\"ActionNodes__Drive___4016_om\"},{\"@id\":\"ActionNodes__Drive___4017_om\"},{\"@id\":\"ActionNodes__Drive___4018\"},{\"@id\":\"ActionNodes__Drive___4019_om\"},{\"@id\":\"ActionNodes__Drive___4020_om\"}]" ; - json:ownedFeature "[{\"@id\":\"ActionNodes__Drive__speed\"},{\"@id\":\"ActionNodes__Drive__log\"},{\"@id\":\"ActionNodes__Drive__antenna\"},{\"@id\":\"ActionNodes__Drive__brake\"},{\"@id\":\"ActionNodes__Drive__split\"},{\"@id\":\"ActionNodes__Drive__sync\"},{\"@id\":\"ActionNodes__Drive__gather\"},{\"@id\":\"ActionNodes__Drive__pick\"},{\"@id\":\"ActionNodes__Drive___4010\"},{\"@id\":\"ActionNodes__Drive__Brake\"},{\"@id\":\"ActionNodes__Drive___4012\"},{\"@id\":\"ActionNodes__Drive___4013\"},{\"@id\":\"ActionNodes__Drive___4014\"},{\"@id\":\"ActionNodes__Drive___4015\"},{\"@id\":\"ActionNodes__Drive___4019\"},{\"@id\":\"ActionNodes__Drive___4020\"}]" ; - json:ownedFeatureMembership "[{\"@id\":\"ActionNodes__Drive__speed_om\"},{\"@id\":\"ActionNodes__Drive__log_om\"},{\"@id\":\"ActionNodes__Drive__antenna_om\"},{\"@id\":\"ActionNodes__Drive__brake_om\"},{\"@id\":\"ActionNodes__Drive__split_om\"},{\"@id\":\"ActionNodes__Drive__sync_om\"},{\"@id\":\"ActionNodes__Drive__gather_om\"},{\"@id\":\"ActionNodes__Drive__pick_om\"},{\"@id\":\"ActionNodes__Drive___4010_om\"},{\"@id\":\"ActionNodes__Drive__Brake_om\"},{\"@id\":\"ActionNodes__Drive___4012_om\"},{\"@id\":\"ActionNodes__Drive___4013_om\"},{\"@id\":\"ActionNodes__Drive___4014_om\"},{\"@id\":\"ActionNodes__Drive___4015_om\"},{\"@id\":\"ActionNodes__Drive___4019_om\"},{\"@id\":\"ActionNodes__Drive___4020_om\"}]" . + json:ownedFeature "[{\"@id\":\"ActionNodes__Drive__speed\"},{\"@id\":\"ActionNodes__Drive__log\"},{\"@id\":\"ActionNodes__Drive__antenna\"},{\"@id\":\"ActionNodes__Drive__brake\"},{\"@id\":\"ActionNodes__Drive__split\"},{\"@id\":\"ActionNodes__Drive__sync\"},{\"@id\":\"ActionNodes__Drive__gather\"},{\"@id\":\"ActionNodes__Drive__pick\"},{\"@id\":\"ActionNodes__Drive___4010\"},{\"@id\":\"ActionNodes__Drive__Brake\"},{\"@id\":\"ActionNodes__Drive___4012\"},{\"@id\":\"ActionNodes__Drive___4013\"},{\"@id\":\"ActionNodes__Drive___4014\"},{\"@id\":\"ActionNodes__Drive___4015\"},{\"@id\":\"ActionNodes__Drive___4016\"},{\"@id\":\"ActionNodes__Drive___4017\"},{\"@id\":\"ActionNodes__Drive___4019\"},{\"@id\":\"ActionNodes__Drive___4020\"}]" ; + json:ownedFeatureMembership "[{\"@id\":\"ActionNodes__Drive__speed_om\"},{\"@id\":\"ActionNodes__Drive__log_om\"},{\"@id\":\"ActionNodes__Drive__antenna_om\"},{\"@id\":\"ActionNodes__Drive__brake_om\"},{\"@id\":\"ActionNodes__Drive__split_om\"},{\"@id\":\"ActionNodes__Drive__sync_om\"},{\"@id\":\"ActionNodes__Drive__gather_om\"},{\"@id\":\"ActionNodes__Drive__pick_om\"},{\"@id\":\"ActionNodes__Drive___4010_om\"},{\"@id\":\"ActionNodes__Drive__Brake_om\"},{\"@id\":\"ActionNodes__Drive___4012_om\"},{\"@id\":\"ActionNodes__Drive___4013_om\"},{\"@id\":\"ActionNodes__Drive___4014_om\"},{\"@id\":\"ActionNodes__Drive___4015_om\"},{\"@id\":\"ActionNodes__Drive___4016_om\"},{\"@id\":\"ActionNodes__Drive___4017_om\"},{\"@id\":\"ActionNodes__Drive___4019_om\"},{\"@id\":\"ActionNodes__Drive___4020_om\"}]" . elmt:ActionNodes__Drive_om a sysml:OwningMembership ; @@ -1300,14 +1300,16 @@ elmt:ActionNodes__Drive___4016 sysx:sourceText " terminate;\n" . elmt:ActionNodes__Drive___4016_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "ActionNodes__Drive___4016_om" ; sysml:owner elmt:ActionNodes__Drive ; sysml:memberElement elmt:ActionNodes__Drive___4016 ; sysml:ownedMemberElement elmt:ActionNodes__Drive___4016 ; sysml:ownedRelatedElement elmt:ActionNodes__Drive___4016 ; sysml:owningRelatedElement elmt:ActionNodes__Drive ; - sysml:membershipOwningNamespace elmt:ActionNodes__Drive . + sysml:membershipOwningNamespace elmt:ActionNodes__Drive ; + sysml:ownedMemberFeature elmt:ActionNodes__Drive___4016 ; + sysml:owningType elmt:ActionNodes__Drive . elmt:ActionNodes__Drive___4017 a sysml:TerminateActionUsage ; @@ -1328,14 +1330,16 @@ elmt:ActionNodes__Drive___4017 sysx:sourceText " terminate brake;\n" . elmt:ActionNodes__Drive___4017_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "ActionNodes__Drive___4017_om" ; sysml:owner elmt:ActionNodes__Drive ; sysml:memberElement elmt:ActionNodes__Drive___4017 ; sysml:ownedMemberElement elmt:ActionNodes__Drive___4017 ; sysml:ownedRelatedElement elmt:ActionNodes__Drive___4017 ; sysml:owningRelatedElement elmt:ActionNodes__Drive ; - sysml:membershipOwningNamespace elmt:ActionNodes__Drive . + sysml:membershipOwningNamespace elmt:ActionNodes__Drive ; + sysml:ownedMemberFeature elmt:ActionNodes__Drive___4017 ; + sysml:owningType elmt:ActionNodes__Drive . expr:ActionNodes__Drive___4017_pexpression a sysml:FeatureReferenceExpression ; diff --git a/tests/export/testdata/convert/bounds.golden.ttl b/tests/export/testdata/convert/bounds.golden.ttl index f5336549c7..0d89b37540 100644 --- a/tests/export/testdata/convert/bounds.golden.ttl +++ b/tests/export/testdata/convert/bounds.golden.ttl @@ -380,7 +380,7 @@ elmt:Bounds__Fleet__loose sysml:owningMembership elmt:Bounds__Fleet__loose_om ; sysml:declaredName "loose" ; sysml:isOrdered "true"^^xsd:boolean ; - sysml:isNonunique "true"^^xsd:boolean ; + sysml:isUnique "false"^^xsd:boolean ; sysml:type elmt:Bounds__Vehicle ; sysml:multiplicity expr:Bounds__Fleet__loose_pmultiplicity ; sysml:ownedRelationship expr:Bounds__Fleet__loose_pmultiplicity_om, elmt:Bounds__Fleet__loose_ft0 ; diff --git a/tests/export/testdata/convert/end_binding_bodies.golden.ttl b/tests/export/testdata/convert/end_binding_bodies.golden.ttl index 5d6a14785b..6dca1c1597 100644 --- a/tests/export/testdata/convert/end_binding_bodies.golden.ttl +++ b/tests/export/testdata/convert/end_binding_bodies.golden.ttl @@ -1102,15 +1102,15 @@ elmt:Bodies__Ctx sysml:ownedMember elmt:Bodies__Ctx__x, elmt:Bodies__Ctx__y, elmt:Bodies__Ctx__c, elmt:Bodies__Ctx___403, elmt:Bodies__Ctx__f, elmt:Bodies__Ctx__bd, elmt:Bodies__Ctx___406, elmt:Bodies__Ctx__al, elmt:Bodies__Ctx__s, elmt:Bodies__Ctx__Act, elmt:Bodies__Ctx__Machine ; sysml:ownedMembership elmt:Bodies__Ctx__x_om, elmt:Bodies__Ctx__y_om, elmt:Bodies__Ctx__c_om, elmt:Bodies__Ctx___403_om, elmt:Bodies__Ctx__f_om, elmt:Bodies__Ctx__bd_om, elmt:Bodies__Ctx___406_om, elmt:Bodies__Ctx__al_om, elmt:Bodies__Ctx__s_om, elmt:Bodies__Ctx__Act_om, elmt:Bodies__Ctx__Machine_om ; sysml:ownedRelationship elmt:Bodies__Ctx__x_om, elmt:Bodies__Ctx__y_om, elmt:Bodies__Ctx__c_om, elmt:Bodies__Ctx___403_om, elmt:Bodies__Ctx__f_om, elmt:Bodies__Ctx__bd_om, elmt:Bodies__Ctx___406_om, elmt:Bodies__Ctx__al_om, elmt:Bodies__Ctx__s_om, elmt:Bodies__Ctx__Act_om, elmt:Bodies__Ctx__Machine_om ; - sysml:ownedFeature elmt:Bodies__Ctx__x, elmt:Bodies__Ctx__y, elmt:Bodies__Ctx__c, elmt:Bodies__Ctx___403, elmt:Bodies__Ctx__bd, elmt:Bodies__Ctx___406, elmt:Bodies__Ctx__al, elmt:Bodies__Ctx__s ; - sysml:ownedFeatureMembership elmt:Bodies__Ctx__x_om, elmt:Bodies__Ctx__y_om, elmt:Bodies__Ctx__c_om, elmt:Bodies__Ctx___403_om, elmt:Bodies__Ctx__bd_om, elmt:Bodies__Ctx___406_om, elmt:Bodies__Ctx__al_om, elmt:Bodies__Ctx__s_om ; + sysml:ownedFeature elmt:Bodies__Ctx__x, elmt:Bodies__Ctx__y, elmt:Bodies__Ctx__c, elmt:Bodies__Ctx___403, elmt:Bodies__Ctx__f, elmt:Bodies__Ctx__bd, elmt:Bodies__Ctx___406, elmt:Bodies__Ctx__al, elmt:Bodies__Ctx__s ; + sysml:ownedFeatureMembership elmt:Bodies__Ctx__x_om, elmt:Bodies__Ctx__y_om, elmt:Bodies__Ctx__c_om, elmt:Bodies__Ctx___403_om, elmt:Bodies__Ctx__f_om, elmt:Bodies__Ctx__bd_om, elmt:Bodies__Ctx___406_om, elmt:Bodies__Ctx__al_om, elmt:Bodies__Ctx__s_om ; sysx:sourceText " part def Ctx {\n" ; sysx:sourceTail " }\n" ; json:ownedMember "[{\"@id\":\"Bodies__Ctx__x\"},{\"@id\":\"Bodies__Ctx__y\"},{\"@id\":\"Bodies__Ctx__c\"},{\"@id\":\"Bodies__Ctx___403\"},{\"@id\":\"Bodies__Ctx__f\"},{\"@id\":\"Bodies__Ctx__bd\"},{\"@id\":\"Bodies__Ctx___406\"},{\"@id\":\"Bodies__Ctx__al\"},{\"@id\":\"Bodies__Ctx__s\"},{\"@id\":\"Bodies__Ctx__Act\"},{\"@id\":\"Bodies__Ctx__Machine\"}]" ; json:ownedMembership "[{\"@id\":\"Bodies__Ctx__x_om\"},{\"@id\":\"Bodies__Ctx__y_om\"},{\"@id\":\"Bodies__Ctx__c_om\"},{\"@id\":\"Bodies__Ctx___403_om\"},{\"@id\":\"Bodies__Ctx__f_om\"},{\"@id\":\"Bodies__Ctx__bd_om\"},{\"@id\":\"Bodies__Ctx___406_om\"},{\"@id\":\"Bodies__Ctx__al_om\"},{\"@id\":\"Bodies__Ctx__s_om\"},{\"@id\":\"Bodies__Ctx__Act_om\"},{\"@id\":\"Bodies__Ctx__Machine_om\"}]" ; json:ownedRelationship "[{\"@id\":\"Bodies__Ctx__x_om\"},{\"@id\":\"Bodies__Ctx__y_om\"},{\"@id\":\"Bodies__Ctx__c_om\"},{\"@id\":\"Bodies__Ctx___403_om\"},{\"@id\":\"Bodies__Ctx__f_om\"},{\"@id\":\"Bodies__Ctx__bd_om\"},{\"@id\":\"Bodies__Ctx___406_om\"},{\"@id\":\"Bodies__Ctx__al_om\"},{\"@id\":\"Bodies__Ctx__s_om\"},{\"@id\":\"Bodies__Ctx__Act_om\"},{\"@id\":\"Bodies__Ctx__Machine_om\"}]" ; - json:ownedFeature "[{\"@id\":\"Bodies__Ctx__x\"},{\"@id\":\"Bodies__Ctx__y\"},{\"@id\":\"Bodies__Ctx__c\"},{\"@id\":\"Bodies__Ctx___403\"},{\"@id\":\"Bodies__Ctx__bd\"},{\"@id\":\"Bodies__Ctx___406\"},{\"@id\":\"Bodies__Ctx__al\"},{\"@id\":\"Bodies__Ctx__s\"}]" ; - json:ownedFeatureMembership "[{\"@id\":\"Bodies__Ctx__x_om\"},{\"@id\":\"Bodies__Ctx__y_om\"},{\"@id\":\"Bodies__Ctx__c_om\"},{\"@id\":\"Bodies__Ctx___403_om\"},{\"@id\":\"Bodies__Ctx__bd_om\"},{\"@id\":\"Bodies__Ctx___406_om\"},{\"@id\":\"Bodies__Ctx__al_om\"},{\"@id\":\"Bodies__Ctx__s_om\"}]" . + json:ownedFeature "[{\"@id\":\"Bodies__Ctx__x\"},{\"@id\":\"Bodies__Ctx__y\"},{\"@id\":\"Bodies__Ctx__c\"},{\"@id\":\"Bodies__Ctx___403\"},{\"@id\":\"Bodies__Ctx__f\"},{\"@id\":\"Bodies__Ctx__bd\"},{\"@id\":\"Bodies__Ctx___406\"},{\"@id\":\"Bodies__Ctx__al\"},{\"@id\":\"Bodies__Ctx__s\"}]" ; + json:ownedFeatureMembership "[{\"@id\":\"Bodies__Ctx__x_om\"},{\"@id\":\"Bodies__Ctx__y_om\"},{\"@id\":\"Bodies__Ctx__c_om\"},{\"@id\":\"Bodies__Ctx___403_om\"},{\"@id\":\"Bodies__Ctx__f_om\"},{\"@id\":\"Bodies__Ctx__bd_om\"},{\"@id\":\"Bodies__Ctx___406_om\"},{\"@id\":\"Bodies__Ctx__al_om\"},{\"@id\":\"Bodies__Ctx__s_om\"}]" . elmt:Bodies__Ctx_om a sysml:OwningMembership ; @@ -1672,8 +1672,8 @@ elmt:Bodies__Ctx__f sysml:connectorEnd expr:Bodies__Ctx__f_pend0, expr:Bodies__Ctx__f_pend1 ; sysml:ownedRelationship expr:Bodies__Ctx__f_pend0_om, expr:Bodies__Ctx__f_pend1_om, elmt:Bodies__Ctx__f__w_om ; sysml:ownedMembership expr:Bodies__Ctx__f_pend0_om, expr:Bodies__Ctx__f_pend1_om, elmt:Bodies__Ctx__f__w_om ; - sysml:ownedFeatureMembership expr:Bodies__Ctx__f_pend0_om, expr:Bodies__Ctx__f_pend1_om ; - sysml:ownedFeature expr:Bodies__Ctx__f_pend0, expr:Bodies__Ctx__f_pend1 ; + sysml:ownedFeatureMembership expr:Bodies__Ctx__f_pend0_om, expr:Bodies__Ctx__f_pend1_om, elmt:Bodies__Ctx__f__w_om ; + sysml:ownedFeature expr:Bodies__Ctx__f_pend0, expr:Bodies__Ctx__f_pend1, elmt:Bodies__Ctx__f__w ; sysml:ownedEndFeature expr:Bodies__Ctx__f_pend0, expr:Bodies__Ctx__f_pend1 ; sysx:endForm "fromTo" ; sysx:hasBody "true"^^xsd:boolean ; @@ -1683,19 +1683,21 @@ elmt:Bodies__Ctx__f json:connectorEnd "[{\"@id\":\"Bodies__Ctx__f_pend0\"},{\"@id\":\"Bodies__Ctx__f_pend1\"}]" ; json:ownedRelationship "[{\"@id\":\"Bodies__Ctx__f_pend0_om\"},{\"@id\":\"Bodies__Ctx__f_pend1_om\"},{\"@id\":\"Bodies__Ctx__f__w_om\"}]" ; json:ownedMembership "[{\"@id\":\"Bodies__Ctx__f_pend0_om\"},{\"@id\":\"Bodies__Ctx__f_pend1_om\"},{\"@id\":\"Bodies__Ctx__f__w_om\"}]" ; - json:ownedFeatureMembership "[{\"@id\":\"Bodies__Ctx__f_pend0_om\"},{\"@id\":\"Bodies__Ctx__f_pend1_om\"}]" ; - json:ownedFeature "[{\"@id\":\"Bodies__Ctx__f_pend0\"},{\"@id\":\"Bodies__Ctx__f_pend1\"}]" ; + json:ownedFeatureMembership "[{\"@id\":\"Bodies__Ctx__f_pend0_om\"},{\"@id\":\"Bodies__Ctx__f_pend1_om\"},{\"@id\":\"Bodies__Ctx__f__w_om\"}]" ; + json:ownedFeature "[{\"@id\":\"Bodies__Ctx__f_pend0\"},{\"@id\":\"Bodies__Ctx__f_pend1\"},{\"@id\":\"Bodies__Ctx__f__w\"}]" ; json:ownedEndFeature "[{\"@id\":\"Bodies__Ctx__f_pend0\"},{\"@id\":\"Bodies__Ctx__f_pend1\"}]" . elmt:Bodies__Ctx__f_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "Bodies__Ctx__f_om" ; sysml:owner elmt:Bodies__Ctx ; sysml:memberElement elmt:Bodies__Ctx__f ; sysml:ownedMemberElement elmt:Bodies__Ctx__f ; sysml:ownedRelatedElement elmt:Bodies__Ctx__f ; sysml:owningRelatedElement elmt:Bodies__Ctx ; - sysml:membershipOwningNamespace elmt:Bodies__Ctx . + sysml:membershipOwningNamespace elmt:Bodies__Ctx ; + sysml:ownedMemberFeature elmt:Bodies__Ctx__f ; + sysml:owningType elmt:Bodies__Ctx . expr:Bodies__Ctx__f_pend0 a sysml:FlowEnd ; @@ -1853,14 +1855,16 @@ elmt:Bodies__Ctx__f__w sysx:sourceText " attribute w : Prio;\n" . elmt:Bodies__Ctx__f__w_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "Bodies__Ctx__f__w_om" ; sysml:owner elmt:Bodies__Ctx__f ; sysml:memberElement elmt:Bodies__Ctx__f__w ; sysml:ownedMemberElement elmt:Bodies__Ctx__f__w ; sysml:ownedRelatedElement elmt:Bodies__Ctx__f__w ; sysml:owningRelatedElement elmt:Bodies__Ctx__f ; - sysml:membershipOwningNamespace elmt:Bodies__Ctx__f . + sysml:membershipOwningNamespace elmt:Bodies__Ctx__f ; + sysml:ownedMemberFeature elmt:Bodies__Ctx__f__w ; + sysml:owningType elmt:Bodies__Ctx__f . elmt:Bodies__Ctx__bd a sysml:BindingConnectorAsUsage ; diff --git a/tests/export/testdata/convert/payload_declaration_bodies.golden.ttl b/tests/export/testdata/convert/payload_declaration_bodies.golden.ttl index e77e5299d5..4aeef35dd9 100644 --- a/tests/export/testdata/convert/payload_declaration_bodies.golden.ttl +++ b/tests/export/testdata/convert/payload_declaration_bodies.golden.ttl @@ -229,14 +229,14 @@ elmt:Payloads__Ctx sysml:ownedMember elmt:Payloads__Ctx__x, elmt:Payloads__Ctx__y, elmt:Payloads__Ctx___402, elmt:Payloads__Ctx__m, elmt:Payloads__Ctx___404 ; sysml:ownedMembership elmt:Payloads__Ctx__x_om, elmt:Payloads__Ctx__y_om, elmt:Payloads__Ctx___402_om, elmt:Payloads__Ctx__m_om, elmt:Payloads__Ctx___404_om ; sysml:ownedRelationship elmt:Payloads__Ctx__x_om, elmt:Payloads__Ctx__y_om, elmt:Payloads__Ctx___402_om, elmt:Payloads__Ctx__m_om, elmt:Payloads__Ctx___404_om ; - sysml:ownedFeature elmt:Payloads__Ctx__x, elmt:Payloads__Ctx__y ; - sysml:ownedFeatureMembership elmt:Payloads__Ctx__x_om, elmt:Payloads__Ctx__y_om ; + sysml:ownedFeature elmt:Payloads__Ctx__x, elmt:Payloads__Ctx__y, elmt:Payloads__Ctx___402, elmt:Payloads__Ctx__m, elmt:Payloads__Ctx___404 ; + sysml:ownedFeatureMembership elmt:Payloads__Ctx__x_om, elmt:Payloads__Ctx__y_om, elmt:Payloads__Ctx___402_om, elmt:Payloads__Ctx__m_om, elmt:Payloads__Ctx___404_om ; sysx:sourceText " part def Ctx {\n part x : A; part y : B;\n flow of fuel : Fuel from x.i to y.j { attribute w : Prio; }\n message m of cmd : Prio from x.i to y.j;\n message of cmd : Prio = m.cmd from x.i to y.j { attribute w : Prio; }\n }\n" ; json:ownedMember "[{\"@id\":\"Payloads__Ctx__x\"},{\"@id\":\"Payloads__Ctx__y\"},{\"@id\":\"Payloads__Ctx___402\"},{\"@id\":\"Payloads__Ctx__m\"},{\"@id\":\"Payloads__Ctx___404\"}]" ; json:ownedMembership "[{\"@id\":\"Payloads__Ctx__x_om\"},{\"@id\":\"Payloads__Ctx__y_om\"},{\"@id\":\"Payloads__Ctx___402_om\"},{\"@id\":\"Payloads__Ctx__m_om\"},{\"@id\":\"Payloads__Ctx___404_om\"}]" ; json:ownedRelationship "[{\"@id\":\"Payloads__Ctx__x_om\"},{\"@id\":\"Payloads__Ctx__y_om\"},{\"@id\":\"Payloads__Ctx___402_om\"},{\"@id\":\"Payloads__Ctx__m_om\"},{\"@id\":\"Payloads__Ctx___404_om\"}]" ; - json:ownedFeature "[{\"@id\":\"Payloads__Ctx__x\"},{\"@id\":\"Payloads__Ctx__y\"}]" ; - json:ownedFeatureMembership "[{\"@id\":\"Payloads__Ctx__x_om\"},{\"@id\":\"Payloads__Ctx__y_om\"}]" . + json:ownedFeature "[{\"@id\":\"Payloads__Ctx__x\"},{\"@id\":\"Payloads__Ctx__y\"},{\"@id\":\"Payloads__Ctx___402\"},{\"@id\":\"Payloads__Ctx__m\"},{\"@id\":\"Payloads__Ctx___404\"}]" ; + json:ownedFeatureMembership "[{\"@id\":\"Payloads__Ctx__x_om\"},{\"@id\":\"Payloads__Ctx__y_om\"},{\"@id\":\"Payloads__Ctx___402_om\"},{\"@id\":\"Payloads__Ctx__m_om\"},{\"@id\":\"Payloads__Ctx___404_om\"}]" . elmt:Payloads__Ctx_om a sysml:OwningMembership ; @@ -328,28 +328,30 @@ elmt:Payloads__Ctx___402 sysml:connectorEnd expr:Payloads__Ctx___402_pend0, expr:Payloads__Ctx___402_pend1 ; sysml:ownedRelationship expr:Payloads__Ctx___402_pend0_om, expr:Payloads__Ctx___402_pend1_om, elmt:Payloads__Ctx___402__fuel_om, elmt:Payloads__Ctx___402__w_om ; sysml:ownedMembership expr:Payloads__Ctx___402_pend0_om, expr:Payloads__Ctx___402_pend1_om, elmt:Payloads__Ctx___402__fuel_om, elmt:Payloads__Ctx___402__w_om ; - sysml:ownedFeatureMembership expr:Payloads__Ctx___402_pend0_om, expr:Payloads__Ctx___402_pend1_om, elmt:Payloads__Ctx___402__fuel_om ; - sysml:ownedFeature expr:Payloads__Ctx___402_pend0, expr:Payloads__Ctx___402_pend1, elmt:Payloads__Ctx___402__fuel ; + sysml:ownedFeatureMembership expr:Payloads__Ctx___402_pend0_om, expr:Payloads__Ctx___402_pend1_om, elmt:Payloads__Ctx___402__fuel_om, elmt:Payloads__Ctx___402__w_om ; + sysml:ownedFeature expr:Payloads__Ctx___402_pend0, expr:Payloads__Ctx___402_pend1, elmt:Payloads__Ctx___402__fuel, elmt:Payloads__Ctx___402__w ; sysml:ownedEndFeature expr:Payloads__Ctx___402_pend0, expr:Payloads__Ctx___402_pend1 ; sysml:ownedMember elmt:Payloads__Ctx___402__fuel, elmt:Payloads__Ctx___402__w ; sysx:hasBody "true"^^xsd:boolean ; json:connectorEnd "[{\"@id\":\"Payloads__Ctx___402_pend0\"},{\"@id\":\"Payloads__Ctx___402_pend1\"}]" ; json:ownedRelationship "[{\"@id\":\"Payloads__Ctx___402_pend0_om\"},{\"@id\":\"Payloads__Ctx___402_pend1_om\"},{\"@id\":\"Payloads__Ctx___402__fuel_om\"},{\"@id\":\"Payloads__Ctx___402__w_om\"}]" ; json:ownedMembership "[{\"@id\":\"Payloads__Ctx___402_pend0_om\"},{\"@id\":\"Payloads__Ctx___402_pend1_om\"},{\"@id\":\"Payloads__Ctx___402__fuel_om\"},{\"@id\":\"Payloads__Ctx___402__w_om\"}]" ; - json:ownedFeatureMembership "[{\"@id\":\"Payloads__Ctx___402_pend0_om\"},{\"@id\":\"Payloads__Ctx___402_pend1_om\"},{\"@id\":\"Payloads__Ctx___402__fuel_om\"}]" ; - json:ownedFeature "[{\"@id\":\"Payloads__Ctx___402_pend0\"},{\"@id\":\"Payloads__Ctx___402_pend1\"},{\"@id\":\"Payloads__Ctx___402__fuel\"}]" ; + json:ownedFeatureMembership "[{\"@id\":\"Payloads__Ctx___402_pend0_om\"},{\"@id\":\"Payloads__Ctx___402_pend1_om\"},{\"@id\":\"Payloads__Ctx___402__fuel_om\"},{\"@id\":\"Payloads__Ctx___402__w_om\"}]" ; + json:ownedFeature "[{\"@id\":\"Payloads__Ctx___402_pend0\"},{\"@id\":\"Payloads__Ctx___402_pend1\"},{\"@id\":\"Payloads__Ctx___402__fuel\"},{\"@id\":\"Payloads__Ctx___402__w\"}]" ; json:ownedEndFeature "[{\"@id\":\"Payloads__Ctx___402_pend0\"},{\"@id\":\"Payloads__Ctx___402_pend1\"}]" ; json:ownedMember "[{\"@id\":\"Payloads__Ctx___402__fuel\"},{\"@id\":\"Payloads__Ctx___402__w\"}]" . elmt:Payloads__Ctx___402_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "Payloads__Ctx___402_om" ; sysml:owner elmt:Payloads__Ctx ; sysml:memberElement elmt:Payloads__Ctx___402 ; sysml:ownedMemberElement elmt:Payloads__Ctx___402 ; sysml:ownedRelatedElement elmt:Payloads__Ctx___402 ; sysml:owningRelatedElement elmt:Payloads__Ctx ; - sysml:membershipOwningNamespace elmt:Payloads__Ctx . + sysml:membershipOwningNamespace elmt:Payloads__Ctx ; + sysml:ownedMemberFeature elmt:Payloads__Ctx___402 ; + sysml:owningType elmt:Payloads__Ctx . expr:Payloads__Ctx___402_pend0 a sysml:FlowEnd ; @@ -538,14 +540,16 @@ elmt:Payloads__Ctx___402__w sysml:ownedRelationship elmt:Payloads__Ctx___402__w_ft0 . elmt:Payloads__Ctx___402__w_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "Payloads__Ctx___402__w_om" ; sysml:owner elmt:Payloads__Ctx___402 ; sysml:memberElement elmt:Payloads__Ctx___402__w ; sysml:ownedMemberElement elmt:Payloads__Ctx___402__w ; sysml:ownedRelatedElement elmt:Payloads__Ctx___402__w ; sysml:owningRelatedElement elmt:Payloads__Ctx___402 ; - sysml:membershipOwningNamespace elmt:Payloads__Ctx___402 . + sysml:membershipOwningNamespace elmt:Payloads__Ctx___402 ; + sysml:ownedMemberFeature elmt:Payloads__Ctx___402__w ; + sysml:owningType elmt:Payloads__Ctx___402 . elmt:Payloads__Ctx__m a sysml:FlowUsage ; @@ -575,14 +579,16 @@ elmt:Payloads__Ctx__m json:parameter "[{\"@id\":\"Payloads__Ctx__m_pend0\"},{\"@id\":\"Payloads__Ctx__m_pend1\"}]" . elmt:Payloads__Ctx__m_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "Payloads__Ctx__m_om" ; sysml:owner elmt:Payloads__Ctx ; sysml:memberElement elmt:Payloads__Ctx__m ; sysml:ownedMemberElement elmt:Payloads__Ctx__m ; sysml:ownedRelatedElement elmt:Payloads__Ctx__m ; sysml:owningRelatedElement elmt:Payloads__Ctx ; - sysml:membershipOwningNamespace elmt:Payloads__Ctx . + sysml:membershipOwningNamespace elmt:Payloads__Ctx ; + sysml:ownedMemberFeature elmt:Payloads__Ctx__m ; + sysml:owningType elmt:Payloads__Ctx . expr:Payloads__Ctx__m_pend0 a sysml:EventOccurrenceUsage ; @@ -789,27 +795,29 @@ elmt:Payloads__Ctx___404 sysml:owningMembership elmt:Payloads__Ctx___404_om ; sysml:ownedRelationship expr:Payloads__Ctx___404_pend0_om, expr:Payloads__Ctx___404_pend1_om, elmt:Payloads__Ctx___404__cmd_om, elmt:Payloads__Ctx___404__w_om ; sysml:ownedMembership expr:Payloads__Ctx___404_pend0_om, expr:Payloads__Ctx___404_pend1_om, elmt:Payloads__Ctx___404__cmd_om, elmt:Payloads__Ctx___404__w_om ; - sysml:ownedFeatureMembership expr:Payloads__Ctx___404_pend0_om, expr:Payloads__Ctx___404_pend1_om, elmt:Payloads__Ctx___404__cmd_om ; - sysml:ownedFeature expr:Payloads__Ctx___404_pend0, expr:Payloads__Ctx___404_pend1, elmt:Payloads__Ctx___404__cmd ; + sysml:ownedFeatureMembership expr:Payloads__Ctx___404_pend0_om, expr:Payloads__Ctx___404_pend1_om, elmt:Payloads__Ctx___404__cmd_om, elmt:Payloads__Ctx___404__w_om ; + sysml:ownedFeature expr:Payloads__Ctx___404_pend0, expr:Payloads__Ctx___404_pend1, elmt:Payloads__Ctx___404__cmd, elmt:Payloads__Ctx___404__w ; sysml:parameter expr:Payloads__Ctx___404_pend0, expr:Payloads__Ctx___404_pend1 ; sysml:ownedMember elmt:Payloads__Ctx___404__cmd, elmt:Payloads__Ctx___404__w ; sysx:hasBody "true"^^xsd:boolean ; json:ownedRelationship "[{\"@id\":\"Payloads__Ctx___404_pend0_om\"},{\"@id\":\"Payloads__Ctx___404_pend1_om\"},{\"@id\":\"Payloads__Ctx___404__cmd_om\"},{\"@id\":\"Payloads__Ctx___404__w_om\"}]" ; json:ownedMembership "[{\"@id\":\"Payloads__Ctx___404_pend0_om\"},{\"@id\":\"Payloads__Ctx___404_pend1_om\"},{\"@id\":\"Payloads__Ctx___404__cmd_om\"},{\"@id\":\"Payloads__Ctx___404__w_om\"}]" ; - json:ownedFeatureMembership "[{\"@id\":\"Payloads__Ctx___404_pend0_om\"},{\"@id\":\"Payloads__Ctx___404_pend1_om\"},{\"@id\":\"Payloads__Ctx___404__cmd_om\"}]" ; - json:ownedFeature "[{\"@id\":\"Payloads__Ctx___404_pend0\"},{\"@id\":\"Payloads__Ctx___404_pend1\"},{\"@id\":\"Payloads__Ctx___404__cmd\"}]" ; + json:ownedFeatureMembership "[{\"@id\":\"Payloads__Ctx___404_pend0_om\"},{\"@id\":\"Payloads__Ctx___404_pend1_om\"},{\"@id\":\"Payloads__Ctx___404__cmd_om\"},{\"@id\":\"Payloads__Ctx___404__w_om\"}]" ; + json:ownedFeature "[{\"@id\":\"Payloads__Ctx___404_pend0\"},{\"@id\":\"Payloads__Ctx___404_pend1\"},{\"@id\":\"Payloads__Ctx___404__cmd\"},{\"@id\":\"Payloads__Ctx___404__w\"}]" ; json:parameter "[{\"@id\":\"Payloads__Ctx___404_pend0\"},{\"@id\":\"Payloads__Ctx___404_pend1\"}]" ; json:ownedMember "[{\"@id\":\"Payloads__Ctx___404__cmd\"},{\"@id\":\"Payloads__Ctx___404__w\"}]" . elmt:Payloads__Ctx___404_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "Payloads__Ctx___404_om" ; sysml:owner elmt:Payloads__Ctx ; sysml:memberElement elmt:Payloads__Ctx___404 ; sysml:ownedMemberElement elmt:Payloads__Ctx___404 ; sysml:ownedRelatedElement elmt:Payloads__Ctx___404 ; sysml:owningRelatedElement elmt:Payloads__Ctx ; - sysml:membershipOwningNamespace elmt:Payloads__Ctx . + sysml:membershipOwningNamespace elmt:Payloads__Ctx ; + sysml:ownedMemberFeature elmt:Payloads__Ctx___404 ; + sysml:owningType elmt:Payloads__Ctx . expr:Payloads__Ctx___404_pend0 a sysml:EventOccurrenceUsage ; @@ -1149,14 +1157,16 @@ elmt:Payloads__Ctx___404__w sysml:ownedRelationship elmt:Payloads__Ctx___404__w_ft0 . elmt:Payloads__Ctx___404__w_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "Payloads__Ctx___404__w_om" ; sysml:owner elmt:Payloads__Ctx___404 ; sysml:memberElement elmt:Payloads__Ctx___404__w ; sysml:ownedMemberElement elmt:Payloads__Ctx___404__w ; sysml:ownedRelatedElement elmt:Payloads__Ctx___404__w ; sysml:owningRelatedElement elmt:Payloads__Ctx___404 ; - sysml:membershipOwningNamespace elmt:Payloads__Ctx___404 . + sysml:membershipOwningNamespace elmt:Payloads__Ctx___404 ; + sysml:ownedMemberFeature elmt:Payloads__Ctx___404__w ; + sysml:owningType elmt:Payloads__Ctx___404 . elmt:Payloads__A__i_ft0 a sysml:FeatureTyping ; diff --git a/tests/export/testdata/convert/then_after_members.golden.ttl b/tests/export/testdata/convert/then_after_members.golden.ttl index ef8ddd9ae6..ce0d8dcd37 100644 --- a/tests/export/testdata/convert/then_after_members.golden.ttl +++ b/tests/export/testdata/convert/then_after_members.golden.ttl @@ -178,15 +178,15 @@ elmt:ThenAfterMembers__AfterFlow sysml:ownedMember elmt:ThenAfterMembers__AfterFlow__a, elmt:ThenAfterMembers__AfterFlow___401, elmt:ThenAfterMembers__AfterFlow__b, elmt:ThenAfterMembers__AfterFlow___403 ; sysml:ownedMembership elmt:ThenAfterMembers__AfterFlow__a_om, elmt:ThenAfterMembers__AfterFlow___401_om, elmt:ThenAfterMembers__AfterFlow__b_om, elmt:ThenAfterMembers__AfterFlow___403_om ; sysml:ownedRelationship elmt:ThenAfterMembers__AfterFlow__a_om, elmt:ThenAfterMembers__AfterFlow___401_om, elmt:ThenAfterMembers__AfterFlow__b_om, elmt:ThenAfterMembers__AfterFlow___403_om ; - sysml:ownedFeature elmt:ThenAfterMembers__AfterFlow__a, elmt:ThenAfterMembers__AfterFlow__b, elmt:ThenAfterMembers__AfterFlow___403 ; - sysml:ownedFeatureMembership elmt:ThenAfterMembers__AfterFlow__a_om, elmt:ThenAfterMembers__AfterFlow__b_om, elmt:ThenAfterMembers__AfterFlow___403_om ; + sysml:ownedFeature elmt:ThenAfterMembers__AfterFlow__a, elmt:ThenAfterMembers__AfterFlow___401, elmt:ThenAfterMembers__AfterFlow__b, elmt:ThenAfterMembers__AfterFlow___403 ; + sysml:ownedFeatureMembership elmt:ThenAfterMembers__AfterFlow__a_om, elmt:ThenAfterMembers__AfterFlow___401_om, elmt:ThenAfterMembers__AfterFlow__b_om, elmt:ThenAfterMembers__AfterFlow___403_om ; sysx:sourceText " action def AfterFlow {\n" ; sysx:sourceTail " }\n" ; json:ownedMember "[{\"@id\":\"ThenAfterMembers__AfterFlow__a\"},{\"@id\":\"ThenAfterMembers__AfterFlow___401\"},{\"@id\":\"ThenAfterMembers__AfterFlow__b\"},{\"@id\":\"ThenAfterMembers__AfterFlow___403\"}]" ; json:ownedMembership "[{\"@id\":\"ThenAfterMembers__AfterFlow__a_om\"},{\"@id\":\"ThenAfterMembers__AfterFlow___401_om\"},{\"@id\":\"ThenAfterMembers__AfterFlow__b_om\"},{\"@id\":\"ThenAfterMembers__AfterFlow___403_om\"}]" ; json:ownedRelationship "[{\"@id\":\"ThenAfterMembers__AfterFlow__a_om\"},{\"@id\":\"ThenAfterMembers__AfterFlow___401_om\"},{\"@id\":\"ThenAfterMembers__AfterFlow__b_om\"},{\"@id\":\"ThenAfterMembers__AfterFlow___403_om\"}]" ; - json:ownedFeature "[{\"@id\":\"ThenAfterMembers__AfterFlow__a\"},{\"@id\":\"ThenAfterMembers__AfterFlow__b\"},{\"@id\":\"ThenAfterMembers__AfterFlow___403\"}]" ; - json:ownedFeatureMembership "[{\"@id\":\"ThenAfterMembers__AfterFlow__a_om\"},{\"@id\":\"ThenAfterMembers__AfterFlow__b_om\"},{\"@id\":\"ThenAfterMembers__AfterFlow___403_om\"}]" . + json:ownedFeature "[{\"@id\":\"ThenAfterMembers__AfterFlow__a\"},{\"@id\":\"ThenAfterMembers__AfterFlow___401\"},{\"@id\":\"ThenAfterMembers__AfterFlow__b\"},{\"@id\":\"ThenAfterMembers__AfterFlow___403\"}]" ; + json:ownedFeatureMembership "[{\"@id\":\"ThenAfterMembers__AfterFlow__a_om\"},{\"@id\":\"ThenAfterMembers__AfterFlow___401_om\"},{\"@id\":\"ThenAfterMembers__AfterFlow__b_om\"},{\"@id\":\"ThenAfterMembers__AfterFlow___403_om\"}]" . elmt:ThenAfterMembers__AfterFlow_om a sysml:OwningMembership ; @@ -261,14 +261,16 @@ elmt:ThenAfterMembers__AfterFlow___401 json:ownedEndFeature "[{\"@id\":\"ThenAfterMembers__AfterFlow___401_pend0\"},{\"@id\":\"ThenAfterMembers__AfterFlow___401_pend1\"}]" . elmt:ThenAfterMembers__AfterFlow___401_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "ThenAfterMembers__AfterFlow___401_om" ; sysml:owner elmt:ThenAfterMembers__AfterFlow ; sysml:memberElement elmt:ThenAfterMembers__AfterFlow___401 ; sysml:ownedMemberElement elmt:ThenAfterMembers__AfterFlow___401 ; sysml:ownedRelatedElement elmt:ThenAfterMembers__AfterFlow___401 ; sysml:owningRelatedElement elmt:ThenAfterMembers__AfterFlow ; - sysml:membershipOwningNamespace elmt:ThenAfterMembers__AfterFlow . + sysml:membershipOwningNamespace elmt:ThenAfterMembers__AfterFlow ; + sysml:ownedMemberFeature elmt:ThenAfterMembers__AfterFlow___401 ; + sysml:owningType elmt:ThenAfterMembers__AfterFlow . expr:ThenAfterMembers__AfterFlow___401_pend0 a sysml:FlowEnd ; @@ -7110,15 +7112,15 @@ elmt:ThenAfterMembers__AfterPerform sysml:ownedMember elmt:ThenAfterMembers__AfterPerform___400, elmt:ThenAfterMembers__AfterPerform___401, elmt:ThenAfterMembers__AfterPerform__b, elmt:ThenAfterMembers__AfterPerform___403 ; sysml:ownedMembership elmt:ThenAfterMembers__AfterPerform___400_om, elmt:ThenAfterMembers__AfterPerform___401_om, elmt:ThenAfterMembers__AfterPerform__b_om, elmt:ThenAfterMembers__AfterPerform___403_om ; sysml:ownedRelationship elmt:ThenAfterMembers__AfterPerform___400_om, elmt:ThenAfterMembers__AfterPerform___401_om, elmt:ThenAfterMembers__AfterPerform__b_om, elmt:ThenAfterMembers__AfterPerform___403_om ; - sysml:ownedFeature elmt:ThenAfterMembers__AfterPerform___400, elmt:ThenAfterMembers__AfterPerform__b, elmt:ThenAfterMembers__AfterPerform___403 ; - sysml:ownedFeatureMembership elmt:ThenAfterMembers__AfterPerform___400_om, elmt:ThenAfterMembers__AfterPerform__b_om, elmt:ThenAfterMembers__AfterPerform___403_om ; + sysml:ownedFeature elmt:ThenAfterMembers__AfterPerform___400, elmt:ThenAfterMembers__AfterPerform___401, elmt:ThenAfterMembers__AfterPerform__b, elmt:ThenAfterMembers__AfterPerform___403 ; + sysml:ownedFeatureMembership elmt:ThenAfterMembers__AfterPerform___400_om, elmt:ThenAfterMembers__AfterPerform___401_om, elmt:ThenAfterMembers__AfterPerform__b_om, elmt:ThenAfterMembers__AfterPerform___403_om ; sysx:sourceText " action def AfterPerform {\n" ; sysx:sourceTail " }\n" ; json:ownedMember "[{\"@id\":\"ThenAfterMembers__AfterPerform___400\"},{\"@id\":\"ThenAfterMembers__AfterPerform___401\"},{\"@id\":\"ThenAfterMembers__AfterPerform__b\"},{\"@id\":\"ThenAfterMembers__AfterPerform___403\"}]" ; json:ownedMembership "[{\"@id\":\"ThenAfterMembers__AfterPerform___400_om\"},{\"@id\":\"ThenAfterMembers__AfterPerform___401_om\"},{\"@id\":\"ThenAfterMembers__AfterPerform__b_om\"},{\"@id\":\"ThenAfterMembers__AfterPerform___403_om\"}]" ; json:ownedRelationship "[{\"@id\":\"ThenAfterMembers__AfterPerform___400_om\"},{\"@id\":\"ThenAfterMembers__AfterPerform___401_om\"},{\"@id\":\"ThenAfterMembers__AfterPerform__b_om\"},{\"@id\":\"ThenAfterMembers__AfterPerform___403_om\"}]" ; - json:ownedFeature "[{\"@id\":\"ThenAfterMembers__AfterPerform___400\"},{\"@id\":\"ThenAfterMembers__AfterPerform__b\"},{\"@id\":\"ThenAfterMembers__AfterPerform___403\"}]" ; - json:ownedFeatureMembership "[{\"@id\":\"ThenAfterMembers__AfterPerform___400_om\"},{\"@id\":\"ThenAfterMembers__AfterPerform__b_om\"},{\"@id\":\"ThenAfterMembers__AfterPerform___403_om\"}]" . + json:ownedFeature "[{\"@id\":\"ThenAfterMembers__AfterPerform___400\"},{\"@id\":\"ThenAfterMembers__AfterPerform___401\"},{\"@id\":\"ThenAfterMembers__AfterPerform__b\"},{\"@id\":\"ThenAfterMembers__AfterPerform___403\"}]" ; + json:ownedFeatureMembership "[{\"@id\":\"ThenAfterMembers__AfterPerform___400_om\"},{\"@id\":\"ThenAfterMembers__AfterPerform___401_om\"},{\"@id\":\"ThenAfterMembers__AfterPerform__b_om\"},{\"@id\":\"ThenAfterMembers__AfterPerform___403_om\"}]" . elmt:ThenAfterMembers__AfterPerform_om a sysml:OwningMembership ; @@ -7194,14 +7196,16 @@ elmt:ThenAfterMembers__AfterPerform___401 json:ownedEndFeature "[{\"@id\":\"ThenAfterMembers__AfterPerform___401_pend0\"},{\"@id\":\"ThenAfterMembers__AfterPerform___401_pend1\"}]" . elmt:ThenAfterMembers__AfterPerform___401_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "ThenAfterMembers__AfterPerform___401_om" ; sysml:owner elmt:ThenAfterMembers__AfterPerform ; sysml:memberElement elmt:ThenAfterMembers__AfterPerform___401 ; sysml:ownedMemberElement elmt:ThenAfterMembers__AfterPerform___401 ; sysml:ownedRelatedElement elmt:ThenAfterMembers__AfterPerform___401 ; sysml:owningRelatedElement elmt:ThenAfterMembers__AfterPerform ; - sysml:membershipOwningNamespace elmt:ThenAfterMembers__AfterPerform . + sysml:membershipOwningNamespace elmt:ThenAfterMembers__AfterPerform ; + sysml:ownedMemberFeature elmt:ThenAfterMembers__AfterPerform___401 ; + sysml:owningType elmt:ThenAfterMembers__AfterPerform . expr:ThenAfterMembers__AfterPerform___401_pend0 a sysml:FlowEnd ; @@ -7489,15 +7493,15 @@ elmt:ThenAfterMembers__ThenAlone sysml:ownedMember elmt:ThenAfterMembers__ThenAlone__a, elmt:ThenAfterMembers__ThenAlone___401, elmt:ThenAfterMembers__ThenAlone___402, elmt:ThenAfterMembers__ThenAlone__b ; sysml:ownedMembership elmt:ThenAfterMembers__ThenAlone__a_om, elmt:ThenAfterMembers__ThenAlone___401_om, elmt:ThenAfterMembers__ThenAlone___402_om, elmt:ThenAfterMembers__ThenAlone__b_om ; sysml:ownedRelationship elmt:ThenAfterMembers__ThenAlone__a_om, elmt:ThenAfterMembers__ThenAlone___401_om, elmt:ThenAfterMembers__ThenAlone___402_om, elmt:ThenAfterMembers__ThenAlone__b_om ; - sysml:ownedFeature elmt:ThenAfterMembers__ThenAlone__a, elmt:ThenAfterMembers__ThenAlone___402, elmt:ThenAfterMembers__ThenAlone__b ; - sysml:ownedFeatureMembership elmt:ThenAfterMembers__ThenAlone__a_om, elmt:ThenAfterMembers__ThenAlone___402_om, elmt:ThenAfterMembers__ThenAlone__b_om ; + sysml:ownedFeature elmt:ThenAfterMembers__ThenAlone__a, elmt:ThenAfterMembers__ThenAlone___401, elmt:ThenAfterMembers__ThenAlone___402, elmt:ThenAfterMembers__ThenAlone__b ; + sysml:ownedFeatureMembership elmt:ThenAfterMembers__ThenAlone__a_om, elmt:ThenAfterMembers__ThenAlone___401_om, elmt:ThenAfterMembers__ThenAlone___402_om, elmt:ThenAfterMembers__ThenAlone__b_om ; sysx:sourceText " action def ThenAlone {\n" ; sysx:sourceTail " }\n" ; json:ownedMember "[{\"@id\":\"ThenAfterMembers__ThenAlone__a\"},{\"@id\":\"ThenAfterMembers__ThenAlone___401\"},{\"@id\":\"ThenAfterMembers__ThenAlone___402\"},{\"@id\":\"ThenAfterMembers__ThenAlone__b\"}]" ; json:ownedMembership "[{\"@id\":\"ThenAfterMembers__ThenAlone__a_om\"},{\"@id\":\"ThenAfterMembers__ThenAlone___401_om\"},{\"@id\":\"ThenAfterMembers__ThenAlone___402_om\"},{\"@id\":\"ThenAfterMembers__ThenAlone__b_om\"}]" ; json:ownedRelationship "[{\"@id\":\"ThenAfterMembers__ThenAlone__a_om\"},{\"@id\":\"ThenAfterMembers__ThenAlone___401_om\"},{\"@id\":\"ThenAfterMembers__ThenAlone___402_om\"},{\"@id\":\"ThenAfterMembers__ThenAlone__b_om\"}]" ; - json:ownedFeature "[{\"@id\":\"ThenAfterMembers__ThenAlone__a\"},{\"@id\":\"ThenAfterMembers__ThenAlone___402\"},{\"@id\":\"ThenAfterMembers__ThenAlone__b\"}]" ; - json:ownedFeatureMembership "[{\"@id\":\"ThenAfterMembers__ThenAlone__a_om\"},{\"@id\":\"ThenAfterMembers__ThenAlone___402_om\"},{\"@id\":\"ThenAfterMembers__ThenAlone__b_om\"}]" . + json:ownedFeature "[{\"@id\":\"ThenAfterMembers__ThenAlone__a\"},{\"@id\":\"ThenAfterMembers__ThenAlone___401\"},{\"@id\":\"ThenAfterMembers__ThenAlone___402\"},{\"@id\":\"ThenAfterMembers__ThenAlone__b\"}]" ; + json:ownedFeatureMembership "[{\"@id\":\"ThenAfterMembers__ThenAlone__a_om\"},{\"@id\":\"ThenAfterMembers__ThenAlone___401_om\"},{\"@id\":\"ThenAfterMembers__ThenAlone___402_om\"},{\"@id\":\"ThenAfterMembers__ThenAlone__b_om\"}]" . elmt:ThenAfterMembers__ThenAlone_om a sysml:OwningMembership ; @@ -7572,14 +7576,16 @@ elmt:ThenAfterMembers__ThenAlone___401 json:ownedEndFeature "[{\"@id\":\"ThenAfterMembers__ThenAlone___401_pend0\"},{\"@id\":\"ThenAfterMembers__ThenAlone___401_pend1\"}]" . elmt:ThenAfterMembers__ThenAlone___401_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "ThenAfterMembers__ThenAlone___401_om" ; sysml:owner elmt:ThenAfterMembers__ThenAlone ; sysml:memberElement elmt:ThenAfterMembers__ThenAlone___401 ; sysml:ownedMemberElement elmt:ThenAfterMembers__ThenAlone___401 ; sysml:ownedRelatedElement elmt:ThenAfterMembers__ThenAlone___401 ; sysml:owningRelatedElement elmt:ThenAfterMembers__ThenAlone ; - sysml:membershipOwningNamespace elmt:ThenAfterMembers__ThenAlone . + sysml:membershipOwningNamespace elmt:ThenAfterMembers__ThenAlone ; + sysml:ownedMemberFeature elmt:ThenAfterMembers__ThenAlone___401 ; + sysml:owningType elmt:ThenAfterMembers__ThenAlone . expr:ThenAfterMembers__ThenAlone___401_pend0 a sysml:FlowEnd ; diff --git a/tests/export/testdata/convert/views_flows_parameters.golden.ttl b/tests/export/testdata/convert/views_flows_parameters.golden.ttl index 56b25ca022..175b96783b 100644 --- a/tests/export/testdata/convert/views_flows_parameters.golden.ttl +++ b/tests/export/testdata/convert/views_flows_parameters.golden.ttl @@ -200,15 +200,15 @@ elmt:FlowsAndViews__FuelInterface sysml:ownedMember elmt:FlowsAndViews__FuelInterface__supplierPort, elmt:FlowsAndViews__FuelInterface__consumerPort, elmt:FlowsAndViews__FuelInterface___402 ; sysml:ownedMembership elmt:FlowsAndViews__FuelInterface__supplierPort_om, elmt:FlowsAndViews__FuelInterface__consumerPort_om, elmt:FlowsAndViews__FuelInterface___402_om ; sysml:ownedRelationship elmt:FlowsAndViews__FuelInterface__supplierPort_om, elmt:FlowsAndViews__FuelInterface__consumerPort_om, elmt:FlowsAndViews__FuelInterface___402_om ; - sysml:ownedFeature elmt:FlowsAndViews__FuelInterface__supplierPort, elmt:FlowsAndViews__FuelInterface__consumerPort ; - sysml:ownedFeatureMembership elmt:FlowsAndViews__FuelInterface__supplierPort_om, elmt:FlowsAndViews__FuelInterface__consumerPort_om ; + sysml:ownedFeature elmt:FlowsAndViews__FuelInterface__supplierPort, elmt:FlowsAndViews__FuelInterface__consumerPort, elmt:FlowsAndViews__FuelInterface___402 ; + sysml:ownedFeatureMembership elmt:FlowsAndViews__FuelInterface__supplierPort_om, elmt:FlowsAndViews__FuelInterface__consumerPort_om, elmt:FlowsAndViews__FuelInterface___402_om ; sysx:sourceText " interface def FuelInterface {\n" ; sysx:sourceTail " }\n" ; json:ownedMember "[{\"@id\":\"FlowsAndViews__FuelInterface__supplierPort\"},{\"@id\":\"FlowsAndViews__FuelInterface__consumerPort\"},{\"@id\":\"FlowsAndViews__FuelInterface___402\"}]" ; json:ownedMembership "[{\"@id\":\"FlowsAndViews__FuelInterface__supplierPort_om\"},{\"@id\":\"FlowsAndViews__FuelInterface__consumerPort_om\"},{\"@id\":\"FlowsAndViews__FuelInterface___402_om\"}]" ; json:ownedRelationship "[{\"@id\":\"FlowsAndViews__FuelInterface__supplierPort_om\"},{\"@id\":\"FlowsAndViews__FuelInterface__consumerPort_om\"},{\"@id\":\"FlowsAndViews__FuelInterface___402_om\"}]" ; - json:ownedFeature "[{\"@id\":\"FlowsAndViews__FuelInterface__supplierPort\"},{\"@id\":\"FlowsAndViews__FuelInterface__consumerPort\"}]" ; - json:ownedFeatureMembership "[{\"@id\":\"FlowsAndViews__FuelInterface__supplierPort_om\"},{\"@id\":\"FlowsAndViews__FuelInterface__consumerPort_om\"}]" . + json:ownedFeature "[{\"@id\":\"FlowsAndViews__FuelInterface__supplierPort\"},{\"@id\":\"FlowsAndViews__FuelInterface__consumerPort\"},{\"@id\":\"FlowsAndViews__FuelInterface___402\"}]" ; + json:ownedFeatureMembership "[{\"@id\":\"FlowsAndViews__FuelInterface__supplierPort_om\"},{\"@id\":\"FlowsAndViews__FuelInterface__consumerPort_om\"},{\"@id\":\"FlowsAndViews__FuelInterface___402_om\"}]" . elmt:FlowsAndViews__FuelInterface_om a sysml:OwningMembership ; @@ -318,14 +318,16 @@ elmt:FlowsAndViews__FuelInterface___402 json:ownedEndFeature "[{\"@id\":\"FlowsAndViews__FuelInterface___402_pend0\"},{\"@id\":\"FlowsAndViews__FuelInterface___402_pend1\"}]" . elmt:FlowsAndViews__FuelInterface___402_om - a sysml:OwningMembership ; + a sysml:FeatureMembership ; sysml:elementId "FlowsAndViews__FuelInterface___402_om" ; sysml:owner elmt:FlowsAndViews__FuelInterface ; sysml:memberElement elmt:FlowsAndViews__FuelInterface___402 ; sysml:ownedMemberElement elmt:FlowsAndViews__FuelInterface___402 ; sysml:ownedRelatedElement elmt:FlowsAndViews__FuelInterface___402 ; sysml:owningRelatedElement elmt:FlowsAndViews__FuelInterface ; - sysml:membershipOwningNamespace elmt:FlowsAndViews__FuelInterface . + sysml:membershipOwningNamespace elmt:FlowsAndViews__FuelInterface ; + sysml:ownedMemberFeature elmt:FlowsAndViews__FuelInterface___402 ; + sysml:owningType elmt:FlowsAndViews__FuelInterface . expr:FlowsAndViews__FuelInterface___402_pend0 a sysml:FlowEnd ; @@ -475,7 +477,7 @@ elmt:FlowsAndViews__tanks sysml:owningRelationship elmt:FlowsAndViews__tanks_om ; sysml:owningMembership elmt:FlowsAndViews__tanks_om ; sysml:declaredName "tanks" ; - sysml:isNonunique "true"^^xsd:boolean ; + sysml:isUnique "false"^^xsd:boolean ; sysml:type elmt:FlowsAndViews__Tank ; sysml:multiplicity expr:FlowsAndViews__tanks_pmultiplicity ; sysml:ownedRelationship expr:FlowsAndViews__tanks_pmultiplicity_om, elmt:FlowsAndViews__tanks_ft0 ; @@ -620,7 +622,7 @@ elmt:FlowsAndViews__vehicle__spares sysml:owningRelationship elmt:FlowsAndViews__vehicle__spares_om ; sysml:owningMembership elmt:FlowsAndViews__vehicle__spares_om ; sysml:declaredName "spares" ; - sysml:isNonunique "true"^^xsd:boolean ; + sysml:isUnique "false"^^xsd:boolean ; sysml:type elmt:FlowsAndViews__Tank ; sysml:subsets elmt:FlowsAndViews__tanks ; sysml:multiplicity expr:FlowsAndViews__vehicle__spares_pmultiplicity ; diff --git a/tests/export/testdata/ontology-known-violations.txt b/tests/export/testdata/ontology-known-violations.txt index 759a2a36ee..c284e683df 100644 --- a/tests/export/testdata/ontology-known-violations.txt +++ b/tests/export/testdata/ontology-known-violations.txt @@ -1,14 +1,13 @@ # Known disagreements between the graphs this tool writes and the OMG SysML v2 -# metamodel as Open-MBEE/sysmlv2-rdf-ontology renders it (version 202407). Each +# metamodel table generated from the pilot's SysML.ecore (version 20250201). Each # line is one violation key — ` ` — and the reason it # is expected; TestGoldenGraphsMatchOntology (internal/translate/export) fails on any # key that is not listed here, and on any listed key no fixture violates any # more. The inventory is tracked in docs/project/roadmap.md § D7 and § D8. # # A key names no element, so this list survives a change of element identity. -# The ontology records no abstractness, so a subject typed by a metaclass that is -# abstract in the metamodel would not be among these findings; every metaclass -# written is checked concrete against the pilot's ecore models by hand instead. +# A subject typed by a metaclass the ecore declares abstract is an abstract-class +# violation, and none is listed: every metaclass this tool writes is concrete. # 1. Properties the metamodel declares on a relationship or membership element # that this tool collapses into the element itself. Ownership and visibility no @@ -17,6 +16,7 @@ domain-mismatch AttributeUsage value # FeatureValue_value: the feature value is written on the usage instead of a FeatureValue membership domain-mismatch ReferenceUsage value # FeatureValue_value: same collapse on a kindless usage's value domain-mismatch AssignmentActionUsage value # FeatureValue_value: same collapse on an assignment's target value +domain-mismatch PayloadFeature value # FeatureValue_value: same collapse on a flow payload's value (`message of cmd : P = m.cmd`) domain-mismatch PartUsage lowerBound # MultiplicityRange_lowerBound: the multiplicity is written on the usage instead of a MultiplicityRange domain-mismatch PartUsage upperBound # MultiplicityRange_upperBound: the multiplicity is written on the usage instead of a MultiplicityRange domain-mismatch ReferenceUsage lowerBound # MultiplicityRange_lowerBound: same collapse on a kindless usage @@ -53,16 +53,11 @@ literal-for-object-property FeatureChaining chainingFeature # F literal-for-object-property FeatureChaining relatedElement # Relationship_relatedElement: same literal on the minted FeatureChaining's relatedElement end literal-for-object-property FeatureChaining target # Relationship_target: same literal on the minted FeatureChaining's target end -# 3. Metaclass names this tool writes into the SysML namespace that the 202407 -# rendering does not declare at all. -unknown-class FlowUsage - # 202407 names this metaclass FlowConnectionUsage; SysML.owl declares no FlowUsage -unknown-class PayloadFeature - # 202407 names this metaclass ItemFeature; SysML.owl declares no PayloadFeature -unknown-class FlowEnd - # 202407 names this metaclass ItemFlowEnd; SysML.owl declares no FlowEnd -unknown-class TerminateActionUsage - # SysML.owl declares no TerminateActionUsage at all (no Terminate* class exists in it) -unknown-class ClassUsage - # a KerML `class` written as a usage; SysML.owl declares Class, a classifier, and no ClassUsage -unknown-class IndividualDefinition - # `individual def`, standardly an OccurrenceDefinition with isIndividual; SysML.owl declares no IndividualDefinition -unknown-class IndividualUsage - # `individual` usage, standardly an OccurrenceUsage with isIndividual; SysML.owl declares no IndividualUsage -unknown-class ConstructorExpression - # KerML 1.0 `new T(...)`, an InstantiationExpression the pilot writes; the 202407 rendering predates the metaclass +# 3. Metaclass names this tool writes into the SysML namespace that the metamodel +# does not declare at all. +unknown-class ClassUsage - # a KerML `class` written as a usage; the metamodel declares Class, a classifier, and no ClassUsage +unknown-class IndividualDefinition - # `individual def`, standardly an OccurrenceDefinition with isIndividual; the metamodel declares no IndividualDefinition +unknown-class IndividualUsage - # `individual` usage, standardly an OccurrenceUsage with isIndividual; the metamodel declares no IndividualUsage # 4. Metaclasses of this tool's own extension namespace, for constructs it has no # standard metaclass for. Deliberately outside the standard vocabulary, so the @@ -105,9 +100,8 @@ unknown-property ActionUsage via # the port an accep unknown-property ReferenceUsage isAccept # notation flag for an accept parameter, no metamodel property unknown-property ReferenceUsage isResult # notation flag for a result parameter, no metamodel property unknown-property PartUsage isChain # notation flag for a feature chain, no metamodel property -unknown-property PartUsage isVariant # Usage::isVariant, which the 202407 rendering omits; the metamodel derives it from the VariantMembership +unknown-property PartUsage isVariant # Usage::isVariant, which the metamodel's ecore does not declare; the variant is its VariantMembership unknown-property EnumerationUsage isVariant # Usage::isVariant on an enumerated value, a variant of its enumeration definition; omitted the same way unknown-property Connector isAll # Type::isSufficient (`connector all from a to b`), written under the notation's own name unknown-property AttributeUsage isAll # Type::isSufficient (`portion feature all slices`), written under the notation's own name -unknown-property AttributeUsage isConstant # Feature::isReadOnly in the 202407 rendering, whose `readonly` the notation has since respelled `const`; written under the notation's own name literal-for-object-property FeatureChainExpression targetFeature # FeatureChainExpression_targetFeature: the `result` of an invocation is no element of the graph and is written as a name diff --git a/tests/migrate/relations_test.go b/tests/migrate/relations_test.go index 11a72b86be..937be53332 100644 --- a/tests/migrate/relations_test.go +++ b/tests/migrate/relations_test.go @@ -1171,7 +1171,7 @@ func TestCollectionModifiersAreWritten(t *testing.T) { if err != nil { t.Fatal(err) } - for _, want := range []string{"isOrdered", "isNonunique"} { + for _, want := range []string{"isOrdered", `isUnique "false"`} { if !strings.Contains(string(ttl), want) { t.Errorf("Turtle lacks %s", want) } diff --git a/tests/ontology/ontology_test.go b/tests/ontology/ontology_test.go index 0d339d661d..028f94325e 100644 --- a/tests/ontology/ontology_test.go +++ b/tests/ontology/ontology_test.go @@ -1,6 +1,10 @@ package ontology_test import ( + "os" + "path/filepath" + "reflect" + "regexp" "strings" "testing" @@ -13,7 +17,8 @@ import ( func TestTableShape(t *testing.T) { properties := ontology.Properties() classes := ontology.Classes() - // The counts SysML.owl 202407 declares; an ontology bump is expected to move them. + enumerations := ontology.Enumerations() + // The counts SysML.ecore 20250201 (pilot 2026-08) declares; a metamodel bump is expected to move them. object, datatype := 0, 0 for _, p := range properties { if p.Kind == ontology.ObjectProperty { @@ -22,16 +27,29 @@ func TestTableShape(t *testing.T) { datatype++ } } - if len(classes) != 172 || object != 348 || datatype != 63 { - t.Errorf("table holds %d classes, %d object and %d datatype properties; want 172, 348, 63", + if len(classes) != 175 || object != 351 || datatype != 64 { + t.Errorf("table holds %d classes, %d object and %d datatype properties; want 175, 351, 64", len(classes), object, datatype) } - if got := len(ontology.AmbiguousNames()); got != 59 { - t.Errorf("got %d unqualified names declared by more than one metaclass, want 59", got) + if len(enumerations) != 7 { + t.Errorf("table holds %d enumerations; want 7", len(enumerations)) } - if ontology.Version == "" || len(ontology.SourceCommit) != 40 { - t.Errorf("table header not recorded: version %q, commit %q", - ontology.Version, ontology.SourceCommit) + for _, bounded := range [][2]string{{"MultiplicityRange", "bound"}, {"Flow", "flowEnd"}} { + // Both have ecore upperBound 2, so their API JSON shape is an array. + if declared, ok := ontology.PropertyOf(bounded[0], bounded[1]); !ok || !declared.Many { + t.Errorf("%s::%s should be Many", bounded[0], bounded[1]) + } + } + if got := len(ontology.AmbiguousNames()); got != 58 { + t.Errorf("got %d unqualified names declared by more than one metaclass, want 58", got) + } + if ontology.Version == "" || ontology.SourceTag == "" || len(ontology.SourceCommit) != 40 { + t.Errorf("table header not recorded: version %q, tag %q, commit %q", + ontology.Version, ontology.SourceTag, ontology.SourceCommit) + } + qualified := make(map[string]bool, len(properties)) + for _, p := range properties { + qualified[p.QualifiedName()] = true } for _, p := range properties { if p.IRI != rdf.SysML+p.DefiningClass+"_"+p.Name { @@ -43,12 +61,25 @@ func TestTableShape(t *testing.T) { if p.Range == "" { t.Errorf("%s: no declared range", p.IRI) } + if p.Ordered && !p.Many { + t.Errorf("%s: Ordered on a single-valued property", p.IRI) + } + for _, ref := range append(append(append([]string(nil), p.Redefines...), p.Subsets...), p.Opposite) { + if ref != "" && !qualified[ref] { + t.Errorf("%s: names %s, which is no declared property", p.IRI, ref) + } + } rangeName := ontology.LocalName(p.Range) _, rangeIsClass := ontology.LookupClass(rangeName) if (p.Kind == ontology.ObjectProperty) != rangeIsClass { t.Errorf("%s: %s ranges over %s, which is%s a declared metaclass", p.IRI, p.Kind, p.Range, map[bool]string{true: "", false: " not"}[rangeIsClass]) } + if p.Kind == ontology.DatatypeProperty && strings.HasPrefix(p.Range, rdf.SysML) { + if _, ok := ontology.LookupEnumeration(rangeName); !ok { + t.Errorf("%s: datatype range %s is not a declared enumeration", p.IRI, rangeName) + } + } } for _, c := range classes { for _, parent := range c.Parents { @@ -62,7 +93,31 @@ func TestTableShape(t *testing.T) { } } -// TestLookups checks the accessors against declarations read out of SysML.owl by +func TestEnumerationLookups(t *testing.T) { + enumeration, ok := ontology.LookupEnumeration("FeatureDirectionKind") + if !ok { + t.Fatal("FeatureDirectionKind is not declared") + } + want := []string{"in", "inout", "out"} + if !reflect.DeepEqual(enumeration.Literals, want) { + t.Errorf("FeatureDirectionKind literals: got %v, want %v", enumeration.Literals, want) + } + enumeration.Literals[0] = "changed" + fresh, ok := ontology.LookupEnumeration("FeatureDirectionKind") + if !ok || !reflect.DeepEqual(fresh.Literals, want) { + t.Errorf("LookupEnumeration returned shared literals: got %v", fresh.Literals) + } + all := ontology.Enumerations() + all[0].Literals[0] = "changed" + if again := ontology.Enumerations(); reflect.DeepEqual(all[0].Literals, again[0].Literals) { + t.Error("Enumerations returned shared literals") + } + if _, ok := ontology.LookupEnumeration("NotAnEnumeration"); ok { + t.Error("NotAnEnumeration should not be declared") + } +} + +// TestLookups checks the accessors against declarations read out of SysML.ecore by // hand, including a name two metaclasses declare. func TestLookups(t *testing.T) { declaredName := ontology.LookupProperty("declaredName") @@ -76,9 +131,35 @@ func TestLookups(t *testing.T) { Kind: ontology.DatatypeProperty, Range: rdf.XSD + "string", } - if declaredName[0] != want { + if !reflect.DeepEqual(declaredName[0], want) { t.Errorf("declaredName: got %+v, want %+v", declaredName[0], want) } + ownedFeature, ok := ontology.PropertyOf("Type", "ownedFeature") + wantOwnedFeature := ontology.Property{ + Name: "ownedFeature", + DefiningClass: "Type", + IRI: rdf.SysML + "Type_ownedFeature", + Kind: ontology.ObjectProperty, + Range: rdf.SysML + "Feature", + Many: true, + Ordered: true, + Derived: true, + Subsets: []string{"Namespace::ownedMember"}, + Opposite: "Feature::owningType", + } + if !ok || !reflect.DeepEqual(ownedFeature, wantOwnedFeature) { + t.Errorf("ownedFeature: got %+v, want %+v", ownedFeature, wantOwnedFeature) + } + memberFeature, _ := ontology.PropertyOf("FeatureMembership", "ownedMemberFeature") + if want := []string{"OwningMembership::ownedMemberElement"}; !reflect.DeepEqual(memberFeature.Redefines, want) { + t.Errorf("ownedMemberFeature: redefines %v, want %v", memberFeature.Redefines, want) + } + if element, _ := ontology.LookupClass("Element"); !element.Abstract { + t.Error("Element should be abstract") + } + if part, _ := ontology.LookupClass("PartUsage"); part.Abstract { + t.Error("PartUsage should be concrete") + } owner := ontology.LookupProperty("owningNamespace") if len(owner) != 1 || owner[0].Kind != ontology.ObjectProperty || owner[0].Range != rdf.SysML+"Namespace" { @@ -104,6 +185,26 @@ func TestLookups(t *testing.T) { } } +var pilotPinRe = regexp.MustCompile(`(?m)^PILOT_(TAG|COMMIT)="\$\{PILOT_(?:TAG|COMMIT):-([^}"]*)\}"`) + +// TestTableFollowsThePilotPin fails when scripts/pilot-pin.sh moves without the +// table being regenerated from the metamodel of the new pin. +func TestTableFollowsThePilotPin(t *testing.T) { + data, err := os.ReadFile(filepath.Join("..", "..", "scripts", "pilot-pin.sh")) + if err != nil { + t.Fatal(err) + } + pin := map[string]string{} + for _, m := range pilotPinRe.FindAllStringSubmatch(string(data), -1) { + pin[m[1]] = m[2] + } + if pin["TAG"] != ontology.SourceTag || pin["COMMIT"] != ontology.SourceCommit { + t.Errorf("table generated from pilot %s %s, scripts/pilot-pin.sh pins %s %s; "+ + "regenerate with ./scripts/download-pilot-metamodel.sh && go run -C tools ./gen/ontology", + ontology.SourceTag, ontology.SourceCommit, pin["TAG"], pin["COMMIT"]) + } +} + // TestCheckReportsEachKind exercises the check on a hand-built graph, one triple // per kind, independently of what the export fixtures happen to contain. func TestCheckReportsEachKind(t *testing.T) { @@ -121,6 +222,8 @@ func TestCheckReportsEachKind(t *testing.T) { graph.Add(untyped, rdf.SysMLTerm("declaredName"), rdf.String("u")) odd := rdf.ElementIRI("M::o") graph.Add(odd, rdf.IRI(rdf.RDFType), rdf.SysMLTerm("NotAMetaclass")) + imp := rdf.ElementIRI("M::i") + graph.Add(imp, rdf.IRI(rdf.RDFType), rdf.SysMLTerm("Import")) want := map[string]string{ "unknown-property PartUsage notAProperty": `named "notAProperty"`, @@ -129,6 +232,7 @@ func TestCheckReportsEachKind(t *testing.T) { "iri-for-datatype-property PartUsage declaredName": "owl:DatatypeProperty", "untyped-subject - -": "no rdf:type", "unknown-class NotAMetaclass -": "not an owl:Class", + "abstract-class Import -": "abstract in the metamodel", } got := make(map[string]string) for _, violation := range ontology.Check(graph) { @@ -150,3 +254,19 @@ func TestCheckReportsEachKind(t *testing.T) { } } } + +// TestCheckReadsTheMostSpecificType checks a subject stating several rdf:types as +// the class the graph reader selects, whatever order the types are stated in. +func TestCheckReadsTheMostSpecificType(t *testing.T) { + for _, order := range [][]string{{"Element", "PartUsage"}, {"PartUsage", "Element"}} { + graph := rdf.NewGraph() + part := rdf.ElementIRI("M::p") + for _, class := range order { + graph.Add(part, rdf.IRI(rdf.RDFType), rdf.SysMLTerm(class)) + } + graph.Add(part, rdf.SysMLTerm("isComposite"), rdf.Bool(true)) // declared on Feature + if got := ontology.Check(graph); len(got) != 0 { + t.Errorf("types %v: unexpected violations %v", order, got) + } + } +} diff --git a/tools/gen/ontology/main.go b/tools/gen/ontology/main.go index 3cd60fa60b..233d7f733f 100644 --- a/tools/gen/ontology/main.go +++ b/tools/gen/ontology/main.go @@ -1,88 +1,111 @@ -// Command ontology writes internal/translate/rdf/ontology/table.go from a local -// checkout of https://github.com/Open-MBEE/sysmlv2-rdf-ontology, which is not -// vendored here. The checkout's version and commit SHA go into the header, -// making the table reproducible. +// Command ontology writes internal/translate/rdf/ontology/table.go from the OMG +// SysML v2 metamodel's SysML.ecore as the pinned pilot implementation publishes +// it. scripts/download-pilot-metamodel.sh fetches it into build/pilot-metamodel +// at the commit scripts/pilot-pin.sh pins, which the header records. // -// go run -C tools ./gen/ontology -ontology /path/to/sysmlv2-rdf-ontology +// ./scripts/download-pilot-metamodel.sh +// go run -C tools ./gen/ontology [-check] package main import ( + "bytes" "encoding/xml" "errors" "flag" "fmt" "go/format" - "io" "os" "path/filepath" "regexp" "sort" + "strconv" "strings" + "github.com/Open-MBEE/OpenSysML/tools/oracle/baseline" "github.com/Open-MBEE/OpenSysML/tools/oracle/repo" ) -// tablePath is the generated table, relative to the repository root. -const tablePath = "internal/translate/rdf/ontology/table.go" - const ( + // tablePath is the generated table, relative to the repository root. + tablePath = "internal/translate/rdf/ontology/table.go" + // metamodelDir is where scripts/download-pilot-metamodel.sh puts the pilot's model directory. + metamodelDir = "build/pilot-metamodel" + // ecorePath is the metamodel in that directory and in the pilot repository's org.omg.sysml/model. + ecorePath = "SysML.ecore" + stampPath = ".pilot-pin" sysmlNS = "https://www.omg.org/spec/SysML#" - owlPath = "sysml2/owl/www.omg.org/spec/SysML.owl" - ecorePath = "sysml2/ecore/SysML.ecore" - readme = "sysml2/README.md" - rdfNS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#" - rdfsNS = "http://www.w3.org/2000/01/rdf-schema#" + xsdNS = "http://www.w3.org/2001/XMLSchema#" owlNS = "http://www.w3.org/2002/07/owl#" + xsiNS = "http://www.w3.org/2001/XMLSchema-instance" + regen = "./scripts/download-pilot-metamodel.sh && go run -C tools ./gen/ontology" template = `// Code generated by tools/gen/ontology. DO NOT EDIT. // -// Source: Open-MBEE/sysmlv2-rdf-ontology, %s -// Ecore: %s (property multiplicities) -// Ontology: SysML v2 metamodel version %s (generated from SysML.ecore) -// Commit: %s +// Source: %s %s, org.omg.sysml/model/SysML.ecore +// Commit: %s +// Metamodel: %s // // Regenerate with (see README.md): // -// go run -C tools ./gen/ontology -ontology +// ./scripts/download-pilot-metamodel.sh +// go run -C tools ./gen/ontology package ontology -// Version is the OMG SysML v2 metamodel version the table was generated from. +// Version is the OMG SysML v2 metamodel version the table was generated from, +// the date in the ecore's namespace URI. const Version = %q -// SourceCommit is the sysmlv2-rdf-ontology commit the table was generated from. +// SourceTag is the pilot implementation release the table was generated from. +const SourceTag = %q + +// SourceCommit is the pilot implementation commit the table was generated from. const SourceCommit = %q -// properties holds every owl:ObjectProperty and owl:DatatypeProperty the -// ontology declares, ordered by IRI. +// properties holds every eStructuralFeature the metamodel declares, ordered by IRI. var properties = []Property{ %s} -// classes holds every owl:Class the ontology declares with its named -// rdfs:subClassOf parents, ordered by name. +// enumerations holds every EEnum and its literals in declaration order, ordered by name. +var enumerations = []Enumeration{ +%s} + +// classes holds every EClass the metamodel declares with its eSuperTypes, ordered by name. var classes = []Class{ %s} ` ) +// datatypeRanges maps an ecore primitive, in the pilot's own spelling and in +// Ecore's, to the XSD or OWL datatype the RDF mapping writes it as. +var datatypeRanges = map[string]string{ + "Boolean": xsdNS + "boolean", "EBoolean": xsdNS + "boolean", + "String": xsdNS + "string", "EString": xsdNS + "string", + "Integer": xsdNS + "int", "EInt": xsdNS + "int", + "Real": owlNS + "real", "EDouble": owlNS + "real", +} + func main() { - root := flag.String("ontology", "", "path to a local Open-MBEE/sysmlv2-rdf-ontology checkout") + dir := flag.String("metamodel", "", "directory holding the pilot's SysML.ecore and its .pilot-pin stamp (default "+metamodelDir+" under the repository root)") out := flag.String("out", "", "generated file to write (default "+tablePath+" under the repository root)") + check := flag.Bool("check", false, "fail if the file differs from a fresh table instead of writing it") flag.Parse() - if *root == "" { - fail(fmt.Errorf("-ontology is required: pass a local sysmlv2-rdf-ontology checkout")) + root, err := repo.Root() + if err != nil { + fail(err) } - if repo.NeedsRoot(*root, *out) { - repoRoot, err := repo.Root() - if err != nil { - fail(err) - } - *root = repo.Resolve(repoRoot, *root) - *out = repo.Resolve(repoRoot, *out) - if *out == "" { - *out = filepath.Join(repoRoot, filepath.FromSlash(tablePath)) - } + pin, err := baseline.ReadPin(root) + if err != nil { + fail(err) + } + *dir = repo.Resolve(root, *dir) + if *dir == "" { + *dir = filepath.Join(root, filepath.FromSlash(metamodelDir)) } - if err := run(*root, *out); err != nil { + *out = repo.Resolve(root, *out) + if *out == "" { + *out = filepath.Join(root, filepath.FromSlash(tablePath)) + } + if err := run(*dir, *out, *check, pin); err != nil { fail(err) } } @@ -92,456 +115,314 @@ func fail(err error) { os.Exit(1) } -func run(root, out string) error { - version, err := ontologyVersion(filepath.Join(root, readme)) +// run generates the table from dir and writes it to out, or with check +// compares it against out; the stamp in dir must name pin. +func run(dir, out string, check bool, pin baseline.Pin) error { + src, err := readStamp(filepath.Join(dir, stampPath)) if err != nil { return err } - commit, err := commitSHA(root) + if src.tag != pin.Tag || src.commit != pin.Commit { + return fmt.Errorf("%s holds the metamodel at %s %s, but %s pins %s %s; rerun ./scripts/download-pilot-metamodel.sh", + dir, src.tag, src.commit, baseline.PinPath, pin.Tag, pin.Commit) + } + pkg, err := parseEcore(filepath.Join(dir, ecorePath)) if err != nil { return err } - decls, err := parseOntology(filepath.Join(root, owlPath)) + version, err := metamodelVersion(pkg.NsURI) if err != nil { return err } - features, err := parseEcore(filepath.Join(root, ecorePath)) + properties, classes, err := tables(pkg) if err != nil { - return err + return fmt.Errorf("%s: %w", ecorePath, err) } - properties, classes, err := tables(decls, features) + enums, err := enumerationTables(pkg) if err != nil { - return err + return fmt.Errorf("%s: %w", ecorePath, err) } - source := fmt.Sprintf(template, owlPath, ecorePath, version, commit, version, commit, - propertyLiterals(properties), classLiterals(classes)) + source := fmt.Sprintf(template, src.repo, src.tag, src.commit, pkg.NsURI, version, src.tag, src.commit, + propertyLiterals(properties), enumerationLiterals(enums), classLiterals(classes)) formatted, err := format.Source([]byte(source)) if err != nil { return fmt.Errorf("format generated source: %w", err) } + if check { + // #nosec G304 -- the table to compare is named on the command line. + have, err := os.ReadFile(out) + if err != nil || !bytes.Equal(have, formatted) { + return fmt.Errorf("%s is stale against %s at %s; regenerate with `%s`", out, ecorePath, src.tag, regen) + } + fmt.Printf("%s is current: %d properties, %d classes (metamodel %s, pilot %s)\n", + out, len(properties), len(classes), version, src.tag) + return nil + } if err := os.WriteFile(out, formatted, 0o600); err != nil { return err } - fmt.Printf("wrote %s: %d properties, %d classes (version %s, commit %s)\n", - out, len(properties), len(classes), version, commit[:12]) + fmt.Printf("wrote %s: %d properties, %d classes (metamodel %s, pilot %s, commit %s)\n", + out, len(properties), len(classes), version, src.tag, src.commit[:12]) return nil } -var ( - versionBadge = regexp.MustCompile(`Version-(\d+)-`) - commitSHAPattern = regexp.MustCompile(`^([0-9a-f]{40}|[0-9a-f]{64})$`) -) +// source is the provenance a fetched metamodel directory's stamp records. +type source struct{ tag, commit, repo string } -// ontologyVersion reads the metamodel version out of the checkout's own README -// badge, so the recorded version cannot drift from the file it describes. -func ontologyVersion(path string) (string, error) { - // #nosec G304 -- the checkout to read is named on the command line. +var commitSHAPattern = regexp.MustCompile(`^[0-9a-f]{40}$`) + +// readStamp reads the " " stamp pilot_fetch_subtrees writes. +func readStamp(path string) (source, error) { + // #nosec G304 -- the stamp sits in the metamodel directory named on the command line. data, err := os.ReadFile(path) if err != nil { - return "", fmt.Errorf("read ontology version: %w", err) + return source{}, fmt.Errorf("read the metamodel's pin stamp (fetch it with ./scripts/download-pilot-metamodel.sh): %w", err) } - match := versionBadge.FindSubmatch(data) - if match == nil { - return "", fmt.Errorf("no Version- badge in %s", path) + fields := strings.Fields(string(data)) + if len(fields) != 3 || !commitSHAPattern.MatchString(fields[1]) { + return source{}, fmt.Errorf("%s: want \" \", got %q", path, strings.TrimSpace(string(data))) } - return string(match[1]), nil + return source{tag: fields[0], commit: fields[1], repo: fields[2]}, nil } -func commitSHA(root string) (string, error) { - gitDir, refsDir, err := gitMetadataDirs(root) - if err != nil { - return "", err - } - headPath := filepath.Join(gitDir, "HEAD") - // #nosec G304 -- git metadata path derives from the requested checkout. - head, err := os.ReadFile(headPath) - if err != nil { - return "", gitMetadataErrorf(headPath, "read HEAD: %w", err) - } - headValue := strings.TrimSpace(string(head)) - if strings.HasPrefix(headValue, "ref:") { - ref := strings.TrimSpace(strings.TrimPrefix(headValue, "ref:")) - if !validGitRef(ref) { - return "", gitMetadataErrorf(headPath, "invalid symbolic ref %q", ref) - } - return commitSHAForRef(refsDir, ref) - } - return validateCommitSHA(headValue, headPath) -} +var nsURIVersion = regexp.MustCompile(`^https://www\.omg\.org/spec/SysML/(\d{8})$`) -type gitMetadataError struct { - path string - err error +// metamodelVersion is the date the ecore's nsURI ends in, the version OMG publishes the metamodel under. +func metamodelVersion(nsURI string) (string, error) { + match := nsURIVersion.FindStringSubmatch(nsURI) + if match == nil { + return "", fmt.Errorf("%s: nsURI %q is not https://www.omg.org/spec/SysML/", ecorePath, nsURI) + } + return match[1], nil } -func (e *gitMetadataError) Error() string { - return fmt.Sprintf("git metadata %s: %v", e.path, e.err) +// ePackage and the types below are the part of the ecore XMI the table reads. +type ePackage struct { + NsURI string `xml:"nsURI,attr"` + Classifiers []eClassifier `xml:"eClassifiers"` + Subpackages []struct{} `xml:"eSubpackages"` } -func (e *gitMetadataError) Unwrap() error { - return e.err +type eClassifier struct { + Type string `xml:"http://www.w3.org/2001/XMLSchema-instance type,attr"` + Name string `xml:"name,attr"` + Abstract bool `xml:"abstract,attr"` + SuperTypes string `xml:"eSuperTypes,attr"` + Features []eFeature `xml:"eStructuralFeatures"` + Literals []eLiteral `xml:"eLiterals"` } -func gitMetadataErrorf(path, format string, args ...any) error { - return &gitMetadataError{path: path, err: fmt.Errorf(format, args...)} +type eLiteral struct { + Name string `xml:"name,attr"` } -func gitMetadataDirs(root string) (string, string, error) { - dotGit := filepath.Join(root, ".git") - info, err := os.Stat(dotGit) - if err != nil { - return "", "", gitMetadataErrorf(dotGit, "read .git: %w", err) - } - gitDir := dotGit - if !info.IsDir() { - // #nosec G304 -- .git is derived from the requested checkout. - data, err := os.ReadFile(dotGit) - if err != nil { - return "", "", gitMetadataErrorf(dotGit, "read gitdir: %w", err) - } - line := strings.TrimSpace(string(data)) - const prefix = "gitdir:" - if !strings.HasPrefix(line, prefix) { - return "", "", gitMetadataErrorf(dotGit, "invalid gitdir file") - } - target := strings.TrimSpace(strings.TrimPrefix(line, prefix)) - if target == "" { - return "", "", gitMetadataErrorf(dotGit, "empty gitdir path") - } - if !filepath.IsAbs(target) { - target = filepath.Join(root, target) - } - gitDir = filepath.Clean(target) - info, err = os.Stat(gitDir) - if err != nil { - return "", "", gitMetadataErrorf(dotGit, "read gitdir %s: %w", gitDir, err) - } - if !info.IsDir() { - return "", "", gitMetadataErrorf(dotGit, "gitdir %s is not a directory", gitDir) - } - } - - refsDir := gitDir - commondirPath := filepath.Join(gitDir, "commondir") - // #nosec G304 -- commondir is inside the requested Git metadata directory. - data, err := os.ReadFile(commondirPath) - if err == nil { - commonDir := strings.TrimSpace(string(data)) - if commonDir == "" { - return "", "", gitMetadataErrorf(commondirPath, "empty common directory path") - } - if !filepath.IsAbs(commonDir) { - commonDir = filepath.Join(gitDir, commonDir) - } - refsDir = filepath.Clean(commonDir) - info, err := os.Stat(refsDir) - if err != nil { - return "", "", gitMetadataErrorf(commondirPath, "read common directory %s: %w", refsDir, err) - } - if !info.IsDir() { - return "", "", gitMetadataErrorf(commondirPath, "common directory %s is not a directory", refsDir) - } - } else if !errors.Is(err, os.ErrNotExist) { - return "", "", gitMetadataErrorf(commondirPath, "read common directory: %w", err) - } - return gitDir, refsDir, nil +type eFeature struct { + Type string `xml:"http://www.w3.org/2001/XMLSchema-instance type,attr"` + Name string `xml:"name,attr"` + EType string `xml:"eType,attr"` + UpperBound string `xml:"upperBound,attr"` + Ordered string `xml:"ordered,attr"` + Derived bool `xml:"derived,attr"` + Opposite string `xml:"eOpposite,attr"` + Annotations []eAnnotation `xml:"eAnnotations"` } -func validGitRef(ref string) bool { - if !strings.HasPrefix(ref, "refs/") || strings.ContainsAny(ref, " \t\r\n") { - return false - } - for _, part := range strings.Split(ref, "/") { - if part == "" || part == "." || part == ".." { - return false - } - } - return true +type eAnnotation struct { + Source string `xml:"source,attr"` + References string `xml:"references,attr"` } -func commitSHAForRef(refsDir, ref string) (string, error) { - loosePath := filepath.Join(refsDir, filepath.FromSlash(ref)) - // #nosec G304 -- ref is validated before it is joined to the Git directory. - data, err := os.ReadFile(loosePath) - if err == nil { - return validateCommitSHA(strings.TrimSpace(string(data)), loosePath) +func parseEcore(path string) (ePackage, error) { + // #nosec G304 -- the metamodel directory is named on the command line. + data, err := os.ReadFile(path) + if err != nil { + return ePackage{}, err } - if !errors.Is(err, os.ErrNotExist) { - return "", gitMetadataErrorf(loosePath, "read ref %s: %w", ref, err) + var pkg ePackage + if err := xml.Unmarshal(data, &pkg); err != nil { + return ePackage{}, fmt.Errorf("%s: %w", path, err) } - - packedPath := filepath.Join(refsDir, "packed-refs") - // #nosec G304 -- packed-refs is inside the requested Git metadata directory. - data, err = os.ReadFile(packedPath) - if err != nil { - return "", gitMetadataErrorf(packedPath, "read ref %s: %w", ref, err) + if len(pkg.Subpackages) > 0 { + return ePackage{}, fmt.Errorf("%s: eSubpackages are not supported; the metamodel is one flat package", path) } - for _, line := range strings.Split(string(data), "\n") { - line = strings.TrimSpace(line) - if line == "" || strings.HasPrefix(line, "#") || strings.HasPrefix(line, "^") { - continue - } - fields := strings.Fields(line) - if len(fields) < 2 || fields[1] != ref { - continue - } - return validateCommitSHA(fields[0], packedPath) + if len(pkg.Classifiers) == 0 { + return ePackage{}, fmt.Errorf("%s: no eClassifiers found", path) } - return "", gitMetadataErrorf(packedPath, "ref %s not found", ref) + return pkg, nil } -func validateCommitSHA(sha, path string) (string, error) { - if !commitSHAPattern.MatchString(sha) { - return "", gitMetadataErrorf(path, "invalid commit SHA %q", sha) - } - return sha, nil +// property and class mirror the generated table's types, which cannot be imported: +// the package they live in does not compile until this has run. +type property struct { + name, definingClass, iri, kind, rangeIRI, opposite string + many, ordered, derived bool + redefines, subsets []string } -// declaration is one top-level RDF/XML declaration in the ontology: an -// owl:Class, owl:ObjectProperty or owl:DatatypeProperty. -type declaration struct { - kind string - iri string - label string - domain string - rangeIRI string +type class struct { + name string + abstract bool parents []string } -// parseOntology reads the declarations out of the RDF/XML. Only top-level elements -// of rdf:RDF are read; the anonymous owl:Restriction axioms nested inside them -// state cardinality rather than hierarchy. -func parseOntology(path string) ([]declaration, error) { - // #nosec G304 -- the checkout to read is named on the command line. - file, err := os.Open(path) - if err != nil { - return nil, err - } - defer file.Close() +type enumeration struct { + name string + literals []string +} - decoder := xml.NewDecoder(file) - var ( - decls []declaration - depth int - ) - for { - token, err := decoder.Token() - if err != nil { - if errors.Is(err, io.EOF) { - break - } - return nil, fmt.Errorf("%s: %w", path, err) - } - start, ok := token.(xml.StartElement) - if !ok { - if _, isEnd := token.(xml.EndElement); isEnd { - depth-- - } +func enumerationTables(pkg ePackage) ([]enumeration, error) { + var enums []enumeration + for _, classifier := range pkg.Classifiers { + if classifier.Type != "ecore:EEnum" { continue } - depth++ - if depth != 2 { - continue + if len(classifier.Literals) == 0 { + return nil, fmt.Errorf("EEnum %s has no literals", classifier.Name) } - kind := start.Name.Space + start.Name.Local - switch kind { - case owlNS + "Class", owlNS + "ObjectProperty", owlNS + "DatatypeProperty": - default: - continue - } - decl, err := readDeclaration(decoder, start) - if err != nil { - return nil, fmt.Errorf("%s: %w", path, err) + enum := enumeration{name: classifier.Name, literals: make([]string, 0, len(classifier.Literals))} + for _, literal := range classifier.Literals { + if literal.Name == "" { + return nil, fmt.Errorf("EEnum %s has a literal without a name", classifier.Name) + } + enum.literals = append(enum.literals, literal.Name) } - depth-- - decl.kind = start.Name.Local - decls = append(decls, decl) - } - if len(decls) == 0 { - return nil, fmt.Errorf("%s: no declarations found", path) + enums = append(enums, enum) } - return decls, nil + sort.Slice(enums, func(i, j int) bool { return enums[i].name < enums[j].name }) + return enums, nil } -// readDeclaration consumes one declaration element, reading the direct children -// that carry the table's data and skipping the rest. -func readDeclaration(decoder *xml.Decoder, start xml.StartElement) (declaration, error) { - decl := declaration{iri: attr(start, rdfNS, "about")} - if decl.iri == "" { - return decl, fmt.Errorf("%s declaration without rdf:about", start.Name.Local) - } - for { - token, err := decoder.Token() - if err != nil { - return decl, err +// tables reads the classes and properties out of the package, checking every +// cross-reference resolves inside it. +func tables(pkg ePackage) ([]property, []class, error) { + kinds := map[string]string{} + features := map[string]bool{} + for _, c := range pkg.Classifiers { + if c.Name == "" { + return nil, nil, errors.New("eClassifiers without a name") } - switch t := token.(type) { - case xml.EndElement: - if t.Name == start.Name { - return decl, nil - } - case xml.StartElement: - name := t.Name.Space + t.Name.Local - resource := attr(t, rdfNS, "resource") - switch { - case name == rdfsNS+"label": - text, err := decoder.Token() - if err != nil { - return decl, err - } - if chars, ok := text.(xml.CharData); ok { - decl.label = strings.TrimSpace(string(chars)) - } - case name == rdfsNS+"domain" && resource != "": - decl.domain = resource - case name == rdfsNS+"range" && resource != "": - decl.rangeIRI = resource - case name == rdfsNS+"subClassOf" && resource != "": - decl.parents = append(decl.parents, resource) - default: - if resource == "" { - if err := decoder.Skip(); err != nil { - return decl, err - } - } - } + if _, dup := kinds[c.Name]; dup { + return nil, nil, fmt.Errorf("eClassifiers %s declared twice", c.Name) + } + kinds[c.Name] = c.Type + for _, f := range c.Features { + features[c.Name+"::"+f.Name] = true } } -} - -// parseEcore reads the metamodel's own ecore into a feature table: -// ecoreFeatures[class][feature] is the feature's upperBound attribute, "-1" -// for an unbounded multiplicity. eStructuralFeatures are read under their -// owning eClassifiers element wherever it sits in the package tree. -type ecoreFeatures map[string]map[string]string - -func parseEcore(path string) (ecoreFeatures, error) { - // #nosec G304 -- the checkout to read is named on the command line. - file, err := os.Open(path) - if err != nil { - return nil, err - } - defer file.Close() - - features := ecoreFeatures{} - var classes []string - decoder := xml.NewDecoder(file) - for { - token, err := decoder.Token() - if err != nil { - if errors.Is(err, io.EOF) { - break + var ( + properties []property + classes []class + ) + for _, c := range pkg.Classifiers { + if c.Type != "ecore:EClass" { + if len(c.Features) > 0 { + return nil, nil, fmt.Errorf("%s: a %s with eStructuralFeatures", c.Name, c.Type) } - return nil, fmt.Errorf("%s: %w", path, err) + continue } - switch t := token.(type) { - case xml.StartElement: - switch t.Name.Local { - case "eClassifiers": - classes = append(classes, attr(t, "", "name")) - case "eStructuralFeatures": - if len(classes) == 0 { - return nil, fmt.Errorf("%s: eStructuralFeatures outside any eClassifiers", path) - } - name := attr(t, "", "name") - class := classes[len(classes)-1] - if features[class] == nil { - features[class] = map[string]string{} - } - features[class][name] = attr(t, "", "upperBound") + var parents []string + for _, ref := range strings.Fields(c.SuperTypes) { + parent, ok := strings.CutPrefix(ref, "#//") + if !ok || kinds[parent] != "ecore:EClass" { + return nil, nil, fmt.Errorf("%s: eSuperTypes %s is no EClass of the package", c.Name, ref) } - case xml.EndElement: - if t.Name.Local == "eClassifiers" && len(classes) > 0 { - classes = classes[:len(classes)-1] + parents = append(parents, parent) + } + sort.Strings(parents) + classes = append(classes, class{name: c.Name, abstract: c.Abstract, parents: parents}) + for _, f := range c.Features { + p, err := newProperty(c.Name, f, kinds, features) + if err != nil { + return nil, nil, fmt.Errorf("%s::%s: %w", c.Name, f.Name, err) } + properties = append(properties, p) } } - if len(features) == 0 { - return nil, fmt.Errorf("%s: no eStructuralFeatures found", path) - } - return features, nil + sort.Slice(properties, func(i, j int) bool { return properties[i].iri < properties[j].iri }) + sort.Slice(classes, func(i, j int) bool { return classes[i].name < classes[j].name }) + return properties, classes, nil } -func attr(element xml.StartElement, space, local string) string { - for _, a := range element.Attr { - if a.Name.Local == local && (a.Name.Space == space || a.Name.Space == "") { - return a.Value +func newProperty(defining string, f eFeature, kinds map[string]string, features map[string]bool) (property, error) { + if f.Name == "" || strings.Contains(f.Name, "_") { + return property{}, fmt.Errorf("feature name %q cannot form a _ IRI", f.Name) + } + many, err := isMany(f.UpperBound) + if err != nil { + return property{}, err + } + p := property{ + name: f.Name, + definingClass: defining, + iri: sysmlNS + defining + "_" + f.Name, + many: many, + derived: f.Derived, + } + p.ordered = p.many && f.Ordered != "false" + local, isLocal := strings.CutPrefix(f.EType, "#//") + switch { + case f.Type == "ecore:EReference" && isLocal && kinds[local] == "ecore:EClass": + p.kind, p.rangeIRI = "ObjectProperty", sysmlNS+local + case f.Type == "ecore:EAttribute" && isLocal && kinds[local] == "ecore:EEnum": + p.kind, p.rangeIRI = "DatatypeProperty", sysmlNS+local + case f.Type == "ecore:EAttribute" && !isLocal: + _, primitive, _ := strings.Cut(f.EType, "#//") + if p.rangeIRI = datatypeRanges[primitive]; p.rangeIRI == "" { + return property{}, fmt.Errorf("eType %q is no primitive the table maps", f.EType) + } + p.kind = "DatatypeProperty" + default: + return property{}, fmt.Errorf("a %s typed %q, which the table cannot range over", f.Type, f.EType) + } + if f.Opposite != "" { + var opposite []string + if opposite, err = featureRefs(f.Opposite, features); err != nil { + return property{}, fmt.Errorf("eOpposite: %w", err) + } + if len(opposite) != 1 { + return property{}, fmt.Errorf("eOpposite %q names %d features", f.Opposite, len(opposite)) + } + p.opposite = opposite[0] + } + for _, a := range f.Annotations { + switch a.Source { + case "redefines": + p.redefines, err = featureRefs(a.References, features) + case "subsets": + p.subsets, err = featureRefs(a.References, features) + } + if err != nil { + return property{}, fmt.Errorf("%s: %w", a.Source, err) } } - return "" -} - -// property and class mirror the generated table's types, which cannot be imported: -// the package they live in does not compile until this has run. -type property struct { - name, definingClass, iri, kind, rangeIRI string - many bool + return p, nil } -type class struct { - name string - parents []string +// isMany is EMF's ETypedElement.isMany: a bound above 1, or -1 (unbounded). An absent +// bound is ecore's default 1; -2 (unspecified) is single-valued, and EcoreValidator rejects the rest. +func isMany(upperBound string) (bool, error) { + if upperBound == "" { + return false, nil + } + n, err := strconv.Atoi(upperBound) + if err != nil || n == 0 || n < -2 { + return false, fmt.Errorf("upperBound %q is not -2, -1 or a positive integer, as ecore requires", upperBound) + } + return n > 1 || n == -1, nil } -func tables(decls []declaration, features ecoreFeatures) ([]property, []class, error) { - var ( - properties []property - classes []class - ) - for _, decl := range decls { - if !strings.HasPrefix(decl.iri, sysmlNS) { - return nil, nil, fmt.Errorf("declaration outside the SysML namespace: %s", decl.iri) - } - local := strings.TrimPrefix(decl.iri, sysmlNS) - if decl.kind == "Class" { - var parents []string - for _, parent := range decl.parents { - if strings.HasPrefix(parent, sysmlNS) { - parents = append(parents, strings.TrimPrefix(parent, sysmlNS)) - } - } - sort.Strings(parents) - classes = append(classes, class{name: local, parents: parents}) - continue - } - defining, name, ok := strings.Cut(local, "_") - if !ok { - return nil, nil, fmt.Errorf("property IRI is not _: %s", decl.iri) - } - // The label is the unqualified name; disagreement with the IRI would - // mean the two conventions cannot be mapped onto each other by name. - if decl.label != "" && decl.label != name { - return nil, nil, fmt.Errorf("%s: rdfs:label %q does not match the IRI's property name %q", - decl.iri, decl.label, name) - } - if decl.domain == "" { - return nil, nil, fmt.Errorf("%s: no rdfs:domain", decl.iri) - } - if domain := strings.TrimPrefix(decl.domain, sysmlNS); domain != defining { - return nil, nil, fmt.Errorf("%s: rdfs:domain %s is not the qualifying metaclass %s", - decl.iri, domain, defining) - } - kind := "ObjectProperty" - if decl.kind == "DatatypeProperty" { - kind = "DatatypeProperty" +// featureRefs turns "#//Class/feature ..." references into "Class::feature" names, each a declared feature. +func featureRefs(refs string, features map[string]bool) ([]string, error) { + var out []string + for _, ref := range strings.Fields(refs) { + path, ok := strings.CutPrefix(ref, "#//") + owner, name, qualified := strings.Cut(path, "/") + if !ok || !qualified || !features[owner+"::"+name] { + return nil, fmt.Errorf("%s is no eStructuralFeature of the package", ref) } - upper, ok := features[defining][name] - if !ok { - return nil, nil, fmt.Errorf("%s: no eStructuralFeatures %s.%s in %s", - decl.iri, defining, name, ecorePath) - } - properties = append(properties, property{ - name: name, - definingClass: defining, - iri: decl.iri, - kind: kind, - rangeIRI: decl.rangeIRI, - many: upper == "-1", - }) + out = append(out, owner+"::"+name) } - sort.Slice(properties, func(i, j int) bool { return properties[i].iri < properties[j].iri }) - sort.Slice(classes, func(i, j int) bool { return classes[i].name < classes[j].name }) - return properties, classes, nil + return out, nil } func propertyLiterals(properties []property) string { @@ -549,8 +430,22 @@ func propertyLiterals(properties []property) string { for _, p := range properties { fmt.Fprintf(&b, "\t{Name: %q, DefiningClass: %q, IRI: %q, Kind: %s, Range: %q", p.name, p.definingClass, p.iri, p.kind, p.rangeIRI) - if p.many { - b.WriteString(", Many: true") + for _, flag := range []struct { + name string + set bool + }{{"Many", p.many}, {"Ordered", p.ordered}, {"Derived", p.derived}} { + if flag.set { + fmt.Fprintf(&b, ", %s: true", flag.name) + } + } + if len(p.redefines) > 0 { + fmt.Fprintf(&b, ", Redefines: %s", stringSlice(p.redefines)) + } + if len(p.subsets) > 0 { + fmt.Fprintf(&b, ", Subsets: %s", stringSlice(p.subsets)) + } + if p.opposite != "" { + fmt.Fprintf(&b, ", Opposite: %q", p.opposite) } b.WriteString("},\n") } @@ -560,15 +455,30 @@ func propertyLiterals(properties []property) string { func classLiterals(classes []class) string { var b strings.Builder for _, c := range classes { - if len(c.parents) == 0 { - fmt.Fprintf(&b, "\t{Name: %q},\n", c.name) - continue + fmt.Fprintf(&b, "\t{Name: %q", c.name) + if c.abstract { + b.WriteString(", Abstract: true") } - quoted := make([]string, len(c.parents)) - for i, parent := range c.parents { - quoted[i] = fmt.Sprintf("%q", parent) + if len(c.parents) > 0 { + fmt.Fprintf(&b, ", Parents: %s", stringSlice(c.parents)) } - fmt.Fprintf(&b, "\t{Name: %q, Parents: []string{%s}},\n", c.name, strings.Join(quoted, ", ")) + b.WriteString("},\n") } return b.String() } + +func enumerationLiterals(enums []enumeration) string { + var b strings.Builder + for _, enum := range enums { + fmt.Fprintf(&b, "\t{Name: %q, Literals: %s},\n", enum.name, stringSlice(enum.literals)) + } + return b.String() +} + +func stringSlice(values []string) string { + quoted := make([]string, len(values)) + for i, v := range values { + quoted[i] = fmt.Sprintf("%q", v) + } + return "[]string{" + strings.Join(quoted, ", ") + "}" +} diff --git a/tools/gen/ontology/main_test.go b/tools/gen/ontology/main_test.go deleted file mode 100644 index f64d55b3f1..0000000000 --- a/tools/gen/ontology/main_test.go +++ /dev/null @@ -1,117 +0,0 @@ -package main - -import ( - "errors" - "os" - "path/filepath" - "strings" - "testing" -) - -const testCommitSHA = "0123456789abcdef0123456789abcdef01234567" - -func TestCommitSHASymrefLooseRef(t *testing.T) { - root := newGitTestRoot(t) - writeGitTestFile(t, filepath.Join(root, ".git", "HEAD"), "ref: refs/heads/main\n") - writeGitTestFile(t, filepath.Join(root, ".git", "refs", "heads", "main"), testCommitSHA+"\n") - - assertCommitSHA(t, root, testCommitSHA) -} - -func TestCommitSHASymrefPackedRefs(t *testing.T) { - root := newGitTestRoot(t) - writeGitTestFile(t, filepath.Join(root, ".git", "HEAD"), "ref: refs/heads/main\n") - writeGitTestFile(t, filepath.Join(root, ".git", "packed-refs"), - "# pack-refs with: peeled fully-peeled\n"+testCommitSHA+" refs/heads/main\n") - - assertCommitSHA(t, root, testCommitSHA) -} - -func TestCommitSHADetachedHead(t *testing.T) { - root := newGitTestRoot(t) - writeGitTestFile(t, filepath.Join(root, ".git", "HEAD"), testCommitSHA+"\n") - - assertCommitSHA(t, root, testCommitSHA) -} - -func TestCommitSHA256DetachedHead(t *testing.T) { - root := newGitTestRoot(t) - sha := strings.Repeat("a", 64) - writeGitTestFile(t, filepath.Join(root, ".git", "HEAD"), sha+"\n") - - assertCommitSHA(t, root, sha) -} - -func TestCommitSHAGitdirFile(t *testing.T) { - root := t.TempDir() - gitDir := filepath.Join(root, "gitdir") - if err := os.MkdirAll(gitDir, 0o700); err != nil { - t.Fatal(err) - } - writeGitTestFile(t, filepath.Join(root, ".git"), "gitdir: gitdir\n") - writeGitTestFile(t, filepath.Join(gitDir, "HEAD"), testCommitSHA+"\n") - - assertCommitSHA(t, root, testCommitSHA) -} - -func TestCommitSHAMissingHead(t *testing.T) { - root := newGitTestRoot(t) - - _, err := commitSHA(root) - assertGitMetadataError(t, err) - if !strings.Contains(err.Error(), filepath.Join(".git", "HEAD")) { - t.Fatalf("error %q does not name HEAD", err) - } -} - -func TestCommitSHAMalformedHead(t *testing.T) { - root := newGitTestRoot(t) - writeGitTestFile(t, filepath.Join(root, ".git", "HEAD"), "deadbeef\n") - - _, err := commitSHA(root) - assertGitMetadataError(t, err) - if !strings.Contains(err.Error(), "invalid commit SHA") { - t.Fatalf("error %q does not identify the invalid SHA", err) - } -} - -func newGitTestRoot(t *testing.T) string { - t.Helper() - root := t.TempDir() - if err := os.Mkdir(filepath.Join(root, ".git"), 0o700); err != nil { - t.Fatal(err) - } - return root -} - -func writeGitTestFile(t *testing.T, path, contents string) { - t.Helper() - if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil { - t.Fatal(err) - } - if err := os.WriteFile(path, []byte(contents), 0o600); err != nil { - t.Fatal(err) - } -} - -func assertCommitSHA(t *testing.T, root, want string) { - t.Helper() - got, err := commitSHA(root) - if err != nil { - t.Fatalf("commitSHA: %v", err) - } - if got != want { - t.Fatalf("commitSHA = %q, want %q", got, want) - } -} - -func assertGitMetadataError(t *testing.T, err error) { - t.Helper() - if err == nil { - t.Fatal("commitSHA returned nil error") - } - var metadataErr *gitMetadataError - if !errors.As(err, &metadataErr) { - t.Fatalf("error %T is not a gitMetadataError: %v", err, err) - } -} diff --git a/tools/gen/ontology/run_test.go b/tools/gen/ontology/run_test.go index c01c05abe0..547debbf79 100644 --- a/tools/gen/ontology/run_test.go +++ b/tools/gen/ontology/run_test.go @@ -5,102 +5,127 @@ import ( "path/filepath" "strings" "testing" + + "github.com/Open-MBEE/OpenSysML/tools/oracle/baseline" ) -// sampleOntology is a checkout-shaped excerpt: two classes, an object property, a -// datatype property, a nested restriction (skipped) and a foreign parent (dropped). -const sampleOntology = ` - - - - PartUsage - - - - - - - 0 - - - - - - partDefinition - - - - - - - - -` +const ( + testTag = "2026-08" + testCommitSHA = "0123456789abcdef0123456789abcdef01234567" + testRepo = "https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation.git" +) + +var testPin = baseline.Pin{Tag: testTag, Commit: testCommitSHA} -// sampleEcore carries the features the sample ontology's properties name. +// sampleEcore is a SysML.ecore excerpt: an abstract root, a class with two +// supertypes, an enumeration, every primitive spelling, and every flag the table records. const sampleEcore = ` - - - + + + + + + + + + + + + + + + + + + - - + + + + + + + ` const wantTable = `// Code generated by tools/gen/ontology. DO NOT EDIT. // -// Source: Open-MBEE/sysmlv2-rdf-ontology, sysml2/owl/www.omg.org/spec/SysML.owl -// Ecore: sysml2/ecore/SysML.ecore (property multiplicities) -// Ontology: SysML v2 metamodel version 202407 (generated from SysML.ecore) -// Commit: 0123456789abcdef0123456789abcdef01234567 +// Source: https://github.com/Systems-Modeling/SysML-v2-Pilot-Implementation.git 2026-08, org.omg.sysml/model/SysML.ecore +// Commit: 0123456789abcdef0123456789abcdef01234567 +// Metamodel: https://www.omg.org/spec/SysML/20250201 // // Regenerate with (see README.md): // -// go run -C tools ./gen/ontology -ontology +// ./scripts/download-pilot-metamodel.sh +// go run -C tools ./gen/ontology package ontology -// Version is the OMG SysML v2 metamodel version the table was generated from. -const Version = "202407" +// Version is the OMG SysML v2 metamodel version the table was generated from, +// the date in the ecore's namespace URI. +const Version = "20250201" + +// SourceTag is the pilot implementation release the table was generated from. +const SourceTag = "2026-08" -// SourceCommit is the sysmlv2-rdf-ontology commit the table was generated from. +// SourceCommit is the pilot implementation commit the table was generated from. const SourceCommit = "0123456789abcdef0123456789abcdef01234567" -// properties holds every owl:ObjectProperty and owl:DatatypeProperty the -// ontology declares, ordered by IRI. +// properties holds every eStructuralFeature the metamodel declares, ordered by IRI. var properties = []Property{ + {Name: "isLibraryElement", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_isLibraryElement", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#boolean"}, {Name: "name", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_name", Kind: DatatypeProperty, Range: "http://www.w3.org/2001/XMLSchema#string"}, - {Name: "partDefinition", DefiningClass: "PartUsage", IRI: "https://www.omg.org/spec/SysML#PartUsage_partDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartDefinition", Many: true}, + {Name: "ownedRelationship", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_ownedRelationship", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Many: true, Ordered: true, Opposite: "Element::owningRelatedElement"}, + {Name: "owningRelatedElement", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_owningRelatedElement", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#Element", Opposite: "Element::ownedRelationship"}, + {Name: "visibility", DefiningClass: "Element", IRI: "https://www.omg.org/spec/SysML#Element_visibility", Kind: DatatypeProperty, Range: "https://www.omg.org/spec/SysML#VisibilityKind"}, + {Name: "itemDefinition", DefiningClass: "ItemUsage", IRI: "https://www.omg.org/spec/SysML#ItemUsage_itemDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartDefinition", Many: true, Derived: true}, + {Name: "ownedPart", DefiningClass: "PartDefinition", IRI: "https://www.omg.org/spec/SysML#PartDefinition_ownedPart", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartUsage", Many: true, Ordered: true, Derived: true, Redefines: []string{"Element::ownedRelationship", "ItemUsage::itemDefinition"}}, + {Name: "partDefinition", DefiningClass: "PartUsage", IRI: "https://www.omg.org/spec/SysML#PartUsage_partDefinition", Kind: ObjectProperty, Range: "https://www.omg.org/spec/SysML#PartDefinition", Many: true, Derived: true, Subsets: []string{"ItemUsage::itemDefinition"}}, + {Name: "weight", DefiningClass: "Usage", IRI: "https://www.omg.org/spec/SysML#Usage_weight", Kind: DatatypeProperty, Range: "http://www.w3.org/2002/07/owl#real"}, +} + +// enumerations holds every EEnum and its literals in declaration order, ordered by name. +var enumerations = []Enumeration{ + {Name: "VisibilityKind", Literals: []string{"public"}}, } -// classes holds every owl:Class the ontology declares with its named -// rdfs:subClassOf parents, ordered by name. +// classes holds every EClass the metamodel declares with its eSuperTypes, ordered by name. var classes = []Class{ - {Name: "Element"}, + {Name: "Element", Abstract: true}, + {Name: "ItemUsage", Parents: []string{"Usage"}}, + {Name: "PartDefinition", Parents: []string{"Element"}}, {Name: "PartUsage", Parents: []string{"ItemUsage", "Usage"}}, + {Name: "Usage", Parents: []string{"Element"}}, } ` -// newCheckout lays out the files run reads from a sysmlv2-rdf-ontology checkout. -func newCheckout(t *testing.T, owl string) string { +// newMetamodel lays out the directory scripts/download-pilot-metamodel.sh fetches. +func newMetamodel(t *testing.T, ecore string) string { + t.Helper() + dir := t.TempDir() + writeFile(t, filepath.Join(dir, stampPath), testTag+" "+testCommitSHA+" "+testRepo+"\n") + writeFile(t, filepath.Join(dir, ecorePath), ecore) + return dir +} + +func writeFile(t *testing.T, path, contents string) { t.Helper() - root := newGitTestRoot(t) - writeGitTestFile(t, filepath.Join(root, ".git", "HEAD"), testCommitSHA+"\n") - writeGitTestFile(t, filepath.Join(root, readme), - "# SysML v2 ontology\n\n![version](https://img.shields.io/badge/Version-202407-blue)\n") - writeGitTestFile(t, filepath.Join(root, owlPath), owl) - writeGitTestFile(t, filepath.Join(root, ecorePath), sampleEcore) - return root + if err := os.WriteFile(path, []byte(contents), 0o600); err != nil { + t.Fatal(err) + } } func TestRunWritesTheTable(t *testing.T) { - root := newCheckout(t, sampleOntology) + dir := newMetamodel(t, sampleEcore) out := filepath.Join(t.TempDir(), "table.go") - if err := run(root, out); err != nil { + if err := run(dir, out, false, testPin); err != nil { t.Fatalf("run: %v", err) } got, err := os.ReadFile(out) @@ -112,65 +137,122 @@ func TestRunWritesTheTable(t *testing.T) { } } -func TestRunRejectsAnOntologyTheTableCannotHold(t *testing.T) { - property := func(iri, label, domain string) string { - var b strings.Builder - b.WriteString(``) - if label != "" { - b.WriteString(`` + label + ``) +// TestUpperBoundMultiplicity pins EMF's rule: upper bound 1 (the default) or -2 (unspecified) +// is single-valued; any bound above 1, or -1 (unbounded), is multi-valued. +func TestUpperBoundMultiplicity(t *testing.T) { + for upper, want := range map[string]bool{"": false, "1": false, "-2": false, "2": true, "5": true, "-1": true} { + got, err := isMany(upper) + if err != nil || got != want { + t.Errorf("isMany(%q) = %v, %v; want %v", upper, got, err, want) } - if domain != "" { - b.WriteString(``) + } + for _, upper := range []string{"0", "-3", "many"} { + if _, err := isMany(upper); err == nil { + t.Errorf("isMany(%q) accepted an upper bound ecore cannot mean", upper) } - b.WriteString(``) - return b.String() } +} + +func TestRunWritesABoundedManyProperty(t *testing.T) { + ecore := strings.Replace(sampleEcore, `name="weight" eType=`, `name="weight" upperBound="2" eType=`, 1) + out := filepath.Join(t.TempDir(), "table.go") + if err := run(newMetamodel(t, ecore), out, false, testPin); err != nil { + t.Fatalf("run: %v", err) + } + generated, err := os.ReadFile(out) + if err != nil { + t.Fatal(err) + } + want := `IRI: "https://www.omg.org/spec/SysML#Usage_weight", Kind: DatatypeProperty, Range: "http://www.w3.org/2002/07/owl#real", Many: true, Ordered: true}` + if !strings.Contains(string(generated), want) { + t.Fatalf("upperBound 2 was not generated as Many:\n%s", generated) + } +} + +func TestCheckFailsOnlyOnDrift(t *testing.T) { + dir := newMetamodel(t, sampleEcore) + out := filepath.Join(t.TempDir(), "table.go") + if err := run(dir, out, true, testPin); err == nil || !strings.Contains(err.Error(), "is stale") { + t.Fatalf("check without a table: error %v, want it stale", err) + } + writeFile(t, out, wantTable) + if err := run(dir, out, true, testPin); err != nil { + t.Fatalf("check of the current table: %v", err) + } + writeFile(t, out, strings.Replace(wantTable, `, Derived: true, Subsets`, `, Subsets`, 1)) + if err := run(dir, out, true, testPin); err == nil || !strings.Contains(err.Error(), "is stale") { + t.Fatalf("check of a drifted table: error %v, want it stale", err) + } + if got, _ := os.ReadFile(out); strings.Contains(string(got), `Derived: true, Subsets`) { + t.Fatal("check rewrote the table") + } +} + +func TestRunRefusesAMetamodelOfAnotherPin(t *testing.T) { + dir := newMetamodel(t, sampleEcore) + out := filepath.Join(t.TempDir(), "table.go") + moved := baseline.Pin{Tag: "2026-09", Commit: strings.Repeat("f", 40)} + if err := run(dir, out, false, moved); err == nil || !strings.Contains(err.Error(), "rerun ./scripts/download-pilot-metamodel.sh") { + t.Fatalf("run: error %v, want the stale download named", err) + } + if err := os.Remove(filepath.Join(dir, stampPath)); err != nil { + t.Fatal(err) + } + if err := run(dir, out, false, testPin); err == nil || !strings.Contains(err.Error(), "pin stamp") { + t.Fatalf("run: error %v, want the missing stamp", err) + } + writeFile(t, filepath.Join(dir, stampPath), "2026-08 deadbeef\n") + if err := run(dir, out, false, testPin); err == nil || !strings.Contains(err.Error(), " ") { + t.Fatalf("run: error %v, want the malformed stamp", err) + } +} + +func TestRunRejectsAMetamodelTheTableCannotHold(t *testing.T) { wrap := func(body string) string { - return `` + - body + `` + return `` + body + `` + } + class := func(name, attrs, body string) string { + return `` + body + `` + } + feature := func(kind, name, attrs, body string) string { + return `` + body + `` } + element := func(body string) string { return class("Element", "", body) } cases := []struct { - name, owl, want string + name, ecore, want string }{ - {"no declarations", wrap(``), "no declarations found"}, - {"missing rdf:about", wrap(``), "Class declaration without rdf:about"}, - {"foreign namespace", wrap(``), - "declaration outside the SysML namespace"}, - {"unqualified property", wrap(property(sysmlNS+"name", "", sysmlNS+"Element")), - "property IRI is not _"}, - {"label disagrees", wrap(property(sysmlNS+"Element_name", "title", sysmlNS+"Element")), - `rdfs:label "title" does not match the IRI's property name "name"`}, - {"no domain", wrap(property(sysmlNS+"Element_name", "", "")), "no rdfs:domain"}, - {"domain disagrees", wrap(property(sysmlNS+"Element_name", "", sysmlNS+"Usage")), - "rdfs:domain Usage is not the qualifying metaclass Element"}, - {"truncated file", ``, - "unexpected EOF"}, - {"no ecore feature", wrap(property(sysmlNS+"Element_title", "title", sysmlNS+"Element")), - "no eStructuralFeatures Element.title"}, + {"no classifiers", wrap(``), "no eClassifiers found"}, + {"bad nsURI", strings.Replace(wrap(element("")), "SysML/20250201", "SysML", 1), "is not https://www.omg.org/spec/SysML/"}, + {"subpackage", wrap(element("") + ``), "eSubpackages are not supported"}, + {"duplicate class", wrap(element("") + element("")), "eClassifiers Element declared twice"}, + {"foreign supertype", wrap(class("Usage", `eSuperTypes="#//Thing"`, "")), "eSuperTypes #//Thing is no EClass"}, + {"underscore name", wrap(element(feature("EAttribute", "a_b", `eType="types.ecore#//String"`, ""))), + "cannot form a _ IRI"}, + {"unknown primitive", wrap(element(feature("EAttribute", "n", `eType="types.ecore#//Char"`, ""))), + "no primitive the table maps"}, + {"zero upper bound", wrap(element(feature("EAttribute", "n", `upperBound="0" eType="types.ecore#//String"`, ""))), + `upperBound "0" is not -2, -1 or a positive integer`}, + {"unknown enum range", wrap(element(feature("EAttribute", "n", `eType="#//Missing"`, ""))), + "which the table cannot range over"}, + {"empty enumeration", wrap(``), + "EEnum VisibilityKind has no literals"}, + {"reference to a primitive", wrap(element(feature("EReference", "n", `eType="types.ecore#//String"`, ""))), + "which the table cannot range over"}, + {"dangling opposite", wrap(element(feature("EReference", "n", `eType="#//Element" eOpposite="#//Element/m"`, ""))), + "eOpposite: #//Element/m is no eStructuralFeature"}, + {"dangling subsets", wrap(element(feature("EReference", "n", `eType="#//Element"`, + ``))), "subsets: #//Element/m is no eStructuralFeature"}, + {"unqualified redefines", wrap(element(feature("EReference", "n", `eType="#//Element"`, + ``))), "redefines: #//Element is no eStructuralFeature"}, + {"truncated file", ``, "unexpected EOF"}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { - root := newCheckout(t, tc.owl) - err := run(root, filepath.Join(t.TempDir(), "table.go")) + err := run(newMetamodel(t, tc.ecore), filepath.Join(t.TempDir(), "table.go"), false, testPin) if err == nil || !strings.Contains(err.Error(), tc.want) { t.Fatalf("run: error %v, want one containing %q", err, tc.want) } }) } } - -func TestRunNeedsTheCheckoutsVersionBadge(t *testing.T) { - root := newCheckout(t, sampleOntology) - writeGitTestFile(t, filepath.Join(root, readme), "# no badge here\n") - err := run(root, filepath.Join(t.TempDir(), "table.go")) - if err == nil || !strings.Contains(err.Error(), "no Version- badge") { - t.Fatalf("run: error %v, want the missing badge", err) - } - if err := os.Remove(filepath.Join(root, readme)); err != nil { - t.Fatal(err) - } - err = run(root, filepath.Join(t.TempDir(), "table.go")) - if err == nil || !strings.Contains(err.Error(), "read ontology version") { - t.Fatalf("run: error %v, want the unreadable README", err) - } -} diff --git a/tools/gen/pymetamodel/main.go b/tools/gen/pymetamodel/main.go new file mode 100644 index 0000000000..f7af3c5fbf --- /dev/null +++ b/tools/gen/pymetamodel/main.go @@ -0,0 +1,566 @@ +// Command pymetamodel writes the generated Python view of the SysML metamodel. +// +// go run -C tools ./gen/pymetamodel [-check] +package main + +import ( + "bytes" + "flag" + "fmt" + "os" + "path/filepath" + "sort" + "strings" + "unicode" + + "github.com/Open-MBEE/OpenSysML/internal/translate/rdf/ontology" + "github.com/Open-MBEE/OpenSysML/tools/oracle/repo" +) + +const ( + outputPath = "client/python/opensysml/metamodel/_generated.py" + regenerate = "make python-metamodel" + sysmlNS = "https://www.omg.org/spec/SysML#" + xsdNS = "http://www.w3.org/2001/XMLSchema#" + owlNS = "http://www.w3.org/2002/07/owl#" +) + +var runtimeMembers = []string{ + "METACLASS", "JSON_KEYS", "from_json_key", "json_key", "json_id", + "json_type", "json_value", "graph", "metaclass_name", +} + +var pythonKeywords = keywordSet( + "False None True and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield", +) + +func main() { + out := flag.String("out", outputPath, "generated Python module (default "+outputPath+")") + check := flag.Bool("check", false, "fail if the generated module differs from the output") + flag.Parse() + root, err := repo.Root() + if err != nil { + fail(err) + } + *out = repo.Resolve(root, *out) + if *out == "" { + *out = filepath.Join(root, filepath.FromSlash(outputPath)) + } + data, err := generate(ontology.Classes(), ontology.Properties(), ontology.Enumerations(), + ontology.Version, ontology.SourceTag, ontology.SourceCommit) + if err != nil { + fail(err) + } + if *check { + have, err := os.ReadFile(*out) + if err != nil || !bytes.Equal(have, data) { + fail(fmt.Errorf("%s is stale; regenerate with `%s`", *out, regenerate)) + } + fmt.Printf("%s is current: %d classes, %d properties, %d enumerations (metamodel %s, pilot %s)\n", + *out, len(ontology.Classes()), len(ontology.Properties()), len(ontology.Enumerations()), + ontology.Version, ontology.SourceTag) + return + } + if err := os.WriteFile(*out, data, 0o600); err != nil { + fail(err) + } + fmt.Printf("wrote %s: %d classes, %d properties, %d enumerations (metamodel %s, pilot %s)\n", + *out, len(ontology.Classes()), len(ontology.Properties()), len(ontology.Enumerations()), + ontology.Version, ontology.SourceTag) +} + +func fail(err error) { + fmt.Fprintln(os.Stderr, "pymetamodel:", err) + os.Exit(1) +} + +type model struct { + classes []ontology.Class + properties []ontology.Property + enums []ontology.Enumeration + classBy map[string]ontology.Class + enumBy map[string]ontology.Enumeration + mros map[string][]string + effective map[string]map[string]ontology.Property +} + +func generate(classes []ontology.Class, properties []ontology.Property, enums []ontology.Enumeration, + version, tag, commit string) ([]byte, error) { + m, err := newModel(classes, properties, enums) + if err != nil { + return nil, err + } + var b strings.Builder + fmt.Fprintf(&b, `# Code generated by tools/gen/pymetamodel. DO NOT EDIT. +# Metamodel: %s +# Pilot tag: %s +# Pilot commit: %s +# Regenerate with: %s + +from __future__ import annotations + +import builtins +from enum import Enum +from types import MappingProxyType +from typing import ClassVar, Mapping + +from ._runtime import Many, Opt, _ElementBase # pyright: ignore[reportPrivateUsage] + +METAMODEL_VERSION = %q +SOURCE_TAG = %q +SOURCE_COMMIT = %q + +`, version, tag, commit, regenerate, version, tag, commit) + + for _, enum := range m.enums { + fmt.Fprintf(&b, "class %s(str, Enum):\n", enum.Name) + for _, literal := range enum.Literals { + fmt.Fprintf(&b, " %s = %q\n", strings.ToUpper(literal), literal) + } + b.WriteString("\n\n") + } + + for _, class := range m.classes { + if class.Name == "Element" { + fmt.Fprintf(&b, "class Element(_ElementBase):\n") + } else if len(class.Parents) == 0 { + fmt.Fprintf(&b, "class %s:\n", class.Name) + } else { + fmt.Fprintf(&b, "class %s(%s):\n", class.Name, strings.Join(class.Parents, ", ")) + } + doc := "Metaclass ``" + class.Name + "``." + if class.Abstract { + doc = "Abstract metaclass ``" + class.Name + "``." + } + fmt.Fprintf(&b, " %q\n __slots__ = ()\n", doc) + fmt.Fprintf(&b, " METACLASS: ClassVar[str] = %q\n", class.Name) + writeJSONKeys(&b, class, m) + for _, property := range m.declaredProperties(class.Name) { + snake := toSnake(property.Name) + rangeAnnotation, rangeName, err := m.pythonRange(property) + if err != nil { + return nil, err + } + descriptor := "Opt" + if property.Many { + descriptor = "Many" + } + fmt.Fprintf(&b, " %s: %s[%s] = %s(%q, %q", + snake, descriptor, rangeAnnotation, descriptor, property.Name, rangeName) + if property.Many { + fmt.Fprintf(&b, ", ordered=%s", pythonBool(property.Ordered)) + } + if property.Derived { + b.WriteString(", derived=True") + } + b.WriteString(")\n") + parts := []string{"single"} + if property.Many { + parts = []string{"many"} + if property.Ordered { + parts = append(parts, "ordered") + } + } + if property.Derived { + parts = append(parts, "derived") + } + doc := fmt.Sprintf("``%s::%s`` (%s).", class.Name, property.Name, strings.Join(parts, ", ")) + if len(property.Redefines) > 0 { + targets := make([]string, len(property.Redefines)) + for i, redefined := range property.Redefines { + targets[i] = "``" + redefined + "``" + } + doc += " Redefines " + strings.Join(targets, ", ") + "." + } + fmt.Fprintf(&b, " %q\n", doc) + if property.Name != snake && !pythonKeywords[property.Name] { + fmt.Fprintf(&b, " %s = %s\n", property.Name, snake) + } + } + b.WriteString("\n\n") + } + + b.WriteString("REGISTRY: Mapping[str, builtins.type[Element]] = MappingProxyType({\n") + for _, class := range m.classes { + fmt.Fprintf(&b, " %q: %s,\n", class.Name, class.Name) + } + b.WriteString("})\n\n") + b.WriteString("ENUMERATIONS: Mapping[str, builtins.type[Enum]] = MappingProxyType({\n") + for _, enum := range m.enums { + fmt.Fprintf(&b, " %q: %s,\n", enum.Name, enum.Name) + } + b.WriteString("})\n\nRUNTIME_MEMBERS = frozenset({\n") + for _, name := range runtimeMembers { + fmt.Fprintf(&b, " %q,\n", name) + } + b.WriteString("})\n\n__all__ = [\n") + names := make([]string, 0, len(m.classes)+len(m.enums)+7) + for _, class := range m.classes { + names = append(names, class.Name) + } + for _, enum := range m.enums { + names = append(names, enum.Name) + } + names = append(names, "ENUMERATIONS", "METAMODEL_VERSION", "REGISTRY", "RUNTIME_MEMBERS", + "SOURCE_COMMIT", "SOURCE_TAG") + sort.Strings(names) + for _, name := range names { + fmt.Fprintf(&b, " %q,\n", name) + } + b.WriteString("]\n") + return []byte(b.String()), nil +} + +func newModel(classes []ontology.Class, properties []ontology.Property, + enums []ontology.Enumeration) (*model, error) { + m := &model{ + classes: classes, properties: properties, enums: enums, + classBy: make(map[string]ontology.Class, len(classes)), + enumBy: make(map[string]ontology.Enumeration, len(enums)), + mros: make(map[string][]string, len(classes)), + effective: make(map[string]map[string]ontology.Property, len(classes)), + } + for _, class := range classes { + if class.Name == "" { + return nil, fmt.Errorf("metaclass without a name") + } + if _, duplicate := m.classBy[class.Name]; duplicate { + return nil, fmt.Errorf("metaclass %s is declared more than once", class.Name) + } + m.classBy[class.Name] = class + } + if _, ok := m.classBy["Element"]; !ok { + return nil, fmt.Errorf("metaclass Element is not declared") + } + for _, enum := range enums { + if enum.Name == "" || len(enum.Literals) == 0 { + return nil, fmt.Errorf("enumeration %q has no literals", enum.Name) + } + if _, duplicate := m.enumBy[enum.Name]; duplicate { + return nil, fmt.Errorf("enumeration %s is declared more than once", enum.Name) + } + m.enumBy[enum.Name] = enum + } + for name := range m.enumBy { + if _, exists := m.classBy[name]; exists { + return nil, fmt.Errorf("metaclass and enumeration share generated name %s", name) + } + if contains([]string{"METAMODEL_VERSION", "SOURCE_TAG", "SOURCE_COMMIT", "REGISTRY", + "ENUMERATIONS", "RUNTIME_MEMBERS"}, name) { + return nil, fmt.Errorf("enumeration %s collides with a generated module member", name) + } + } + for _, property := range properties { + if _, ok := m.classBy[property.DefiningClass]; !ok { + return nil, fmt.Errorf("%s::%s has no declaring metaclass", property.DefiningClass, property.Name) + } + } + order, err := m.topologicalOrder() + if err != nil { + return nil, err + } + m.classes = order + for _, class := range m.classes { + if _, err := m.linearize(class.Name, map[string]bool{}); err != nil { + return nil, err + } + } + if err := m.validateDeclarations(); err != nil { + return nil, err + } + for _, class := range m.classes { + effective := make(map[string]ontology.Property) + for _, ancestor := range m.mros[class.Name] { + for _, property := range m.properties { + if property.DefiningClass == ancestor { + if _, exists := effective[property.Name]; !exists { + effective[property.Name] = property + } + } + } + } + m.effective[class.Name] = effective + if err := m.validateEffective(class.Name, effective); err != nil { + return nil, err + } + } + for _, property := range properties { + if _, _, err := m.pythonRange(property); err != nil { + return nil, err + } + } + return m, nil +} + +func (m *model) validateDeclarations() error { + declared := make(map[string][]string) + for _, property := range m.properties { + names := declared[property.Name] + for _, previous := range names { + if m.ancestor(property.DefiningClass, previous) || m.ancestor(previous, property.DefiningClass) { + return fmt.Errorf("property %s is declared by related metaclasses %s and %s", + property.Name, previous, property.DefiningClass) + } + } + declared[property.Name] = append(names, property.DefiningClass) + snake, camel := toSnake(property.Name), property.Name + for _, name := range []string{snake, camel} { + if contains(runtimeMembers, name) { + return fmt.Errorf("property %s on %s collides with runtime member %s", property.Name, property.DefiningClass, name) + } + if m.classBy[name].Name != "" || m.enumBy[name].Name != "" || + contains([]string{"Opt", "Many", "ClassVar", "Mapping", "MappingProxyType", + "builtins", "str", "bool", "int", "float"}, name) { + return fmt.Errorf("property %s on %s shadows generated class-body name %s", property.Name, property.DefiningClass, name) + } + } + if !pythonIdentifier(snake) { + return fmt.Errorf("property %q has no valid Python name", property.Name) + } + } + for _, enum := range m.enums { + literalNames := map[string]bool{} + for _, literal := range enum.Literals { + member := strings.ToUpper(literal) + if !pythonIdentifier(member) || pythonKeywords[member] { + return fmt.Errorf("enum literal %q in %s does not produce a valid Python identifier", literal, enum.Name) + } + if literalNames[member] { + return fmt.Errorf("enum %s has duplicate Python member %s", enum.Name, member) + } + literalNames[member] = true + } + } + return nil +} + +func (m *model) validateEffective(class string, effective map[string]ontology.Property) error { + names := make(map[string]string, len(effective)) + for key := range effective { + snake := toSnake(key) + if previous, exists := names[snake]; exists { + return fmt.Errorf("%s has property keys %s and %s with the same Python name %s", + class, previous, key, snake) + } + names[snake] = key + } + return nil +} + +func (m *model) topologicalOrder() ([]ontology.Class, error) { + children := make(map[string][]string, len(m.classes)) + remaining := make(map[string]int, len(m.classes)) + for _, class := range m.classes { + remaining[class.Name] = len(class.Parents) + for _, parent := range class.Parents { + if _, ok := m.classBy[parent]; !ok { + return nil, fmt.Errorf("%s has unknown metaclass parent %s", class.Name, parent) + } + children[parent] = append(children[parent], class.Name) + } + } + var ready []string + for name, count := range remaining { + if count == 0 { + ready = append(ready, name) + } + } + sort.Strings(ready) + order := make([]ontology.Class, 0, len(m.classes)) + for len(ready) > 0 { + name := ready[0] + ready = ready[1:] + order = append(order, m.classBy[name]) + for _, child := range children[name] { + remaining[child]-- + if remaining[child] == 0 { + ready = append(ready, child) + } + } + sort.Strings(ready) + } + if len(order) != len(m.classes) { + return nil, fmt.Errorf("metaclass inheritance contains a cycle") + } + return order, nil +} + +func (m *model) linearize(name string, visiting map[string]bool) ([]string, error) { + if mro, ok := m.mros[name]; ok { + return mro, nil + } + if visiting[name] { + return nil, fmt.Errorf("C3 linearization failed for %s: inheritance cycle", name) + } + visiting[name] = true + class := m.classBy[name] + sequences := make([][]string, 0, len(class.Parents)+1) + for _, parent := range class.Parents { + parentMRO, err := m.linearize(parent, visiting) + if err != nil { + return nil, err + } + sequences = append(sequences, append([]string(nil), parentMRO...)) + } + sequences = append(sequences, append([]string(nil), class.Parents...)) + result := []string{name} + for { + active := sequences[:0] + for _, sequence := range sequences { + if len(sequence) != 0 { + active = append(active, sequence) + } + } + sequences = active + if len(sequences) == 0 { + break + } + var candidate string + for _, sequence := range sequences { + head := sequence[0] + inTail := false + for _, other := range sequences { + for _, tail := range other[1:] { + if tail == head { + inTail = true + break + } + } + if inTail { + break + } + } + if !inTail { + candidate = head + break + } + } + if candidate == "" { + return nil, fmt.Errorf("C3 linearization failed for %s: inconsistent parents %v", name, class.Parents) + } + result = append(result, candidate) + for i, sequence := range sequences { + if sequence[0] == candidate { + sequences[i] = sequence[1:] + } + } + } + delete(visiting, name) + m.mros[name] = result + return result, nil +} + +func (m *model) ancestor(class, ancestor string) bool { + for _, name := range m.mros[class] { + if name == ancestor { + return true + } + } + return false +} + +func (m *model) declaredProperties(class string) []ontology.Property { + var out []ontology.Property + for _, property := range m.properties { + if property.DefiningClass == class { + out = append(out, property) + } + } + sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name }) + return out +} + +func (m *model) pythonRange(property ontology.Property) (annotation, name string, err error) { + switch property.Range { + case xsdNS + "boolean": + return "bool", "bool", nil + case xsdNS + "string": + return "str", "str", nil + case xsdNS + "int": + return "int", "int", nil + case owlNS + "real": + return "float", "float", nil + } + if local, ok := strings.CutPrefix(property.Range, sysmlNS); ok { + if _, exists := m.classBy[local]; exists && property.Kind == ontology.ObjectProperty { + return local, local, nil + } + if _, exists := m.enumBy[local]; exists && property.Kind == ontology.DatatypeProperty { + return local, local, nil + } + } + return "", "", fmt.Errorf("%s::%s has unsupported range %q", property.DefiningClass, property.Name, property.Range) +} + +func writeJSONKeys(b *strings.Builder, class ontology.Class, m *model) { + b.WriteString(" JSON_KEYS: ClassVar[Mapping[str, str]] = MappingProxyType({\n") + if class.Name == "Element" { + b.WriteString(" **_ElementBase.JSON_KEYS,\n") + } else { + for i := len(class.Parents) - 1; i >= 0; i-- { + fmt.Fprintf(b, " **%s.JSON_KEYS,\n", class.Parents[i]) + } + } + for _, property := range m.declaredProperties(class.Name) { + fmt.Fprintf(b, " %q: %q,\n", property.Name, toSnake(property.Name)) + } + b.WriteString(" })\n") +} + +func toSnake(name string) string { + runes := []rune(name) + var b strings.Builder + for i, current := range runes { + if i > 0 && unicode.IsUpper(current) { + previous := runes[i-1] + nextIsLower := i+1 < len(runes) && unicode.IsLower(runes[i+1]) + if unicode.IsLower(previous) || unicode.IsDigit(previous) || + (unicode.IsUpper(previous) && nextIsLower) { + b.WriteByte('_') + } + } + b.WriteRune(unicode.ToLower(current)) + } + snake := b.String() + if pythonKeywords[snake] { + return snake + "_" + } + return snake +} + +func pythonIdentifier(name string) bool { + for i, r := range name { + if i == 0 { + if r != '_' && !unicode.IsLetter(r) { + return false + } + } else if r != '_' && !unicode.IsLetter(r) && !unicode.IsDigit(r) { + return false + } + } + return name != "" +} + +func pythonBool(value bool) string { + if value { + return "True" + } + return "False" +} + +func keywordSet(words string) map[string]bool { + out := make(map[string]bool) + for _, word := range strings.Fields(words) { + out[word] = true + } + return out +} + +func contains(values []string, value string) bool { + for _, candidate := range values { + if candidate == value { + return true + } + } + return false +} diff --git a/tools/gen/pymetamodel/main_test.go b/tools/gen/pymetamodel/main_test.go new file mode 100644 index 0000000000..a579661395 --- /dev/null +++ b/tools/gen/pymetamodel/main_test.go @@ -0,0 +1,179 @@ +package main + +import ( + "bytes" + "os" + "os/exec" + "path/filepath" + "strings" + "testing" + + "github.com/Open-MBEE/OpenSysML/internal/translate/rdf/ontology" + "github.com/Open-MBEE/OpenSysML/tools/oracle/repo" +) + +func TestGeneratedMetamodel(t *testing.T) { + generated, err := generate(ontology.Classes(), ontology.Properties(), ontology.Enumerations(), + ontology.Version, ontology.SourceTag, ontology.SourceCommit) + if err != nil { + t.Fatal(err) + } + source := string(generated) + if !strings.Contains(source, `class FeatureDirectionKind(str, Enum):`) || + !strings.Contains(source, ` IN = "in"`) { + t.Fatal("generated enumerations are missing") + } + if strings.Index(source, "class Type(") > strings.Index(source, "class PartUsage(") { + t.Fatal("metaclasses are not generated parent-first") + } + if !strings.Contains(source, `"partDefinition": "part_definition"`) { + t.Fatal("generated JSON-key mapping is missing") + } + root, err := repo.Root() + if err != nil { + t.Fatal(err) + } + committed, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(outputPath))) + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(generated, committed) { + t.Fatal("committed generated Python metamodel is stale") + } +} + +func TestCheckRejectsModifiedOutput(t *testing.T) { + root, err := repo.Root() + if err != nil { + t.Fatal(err) + } + output := filepath.Join(t.TempDir(), "stale.py") + if err := os.WriteFile(output, []byte("stale\n"), 0o600); err != nil { + t.Fatal(err) + } + command := exec.Command("go", "run", "./gen/pymetamodel", "-check", "-out", output) + command.Dir = filepath.Join(root, "tools") + result, err := command.CombinedOutput() + if err == nil || !strings.Contains(string(result), "is stale; regenerate with") { + t.Fatalf("generator check output = %s, error = %v", result, err) + } +} + +func TestC3LinearizationOrdersSharedAncestorsOnce(t *testing.T) { + classes := []ontology.Class{ + {Name: "Element"}, + {Name: "Base", Parents: []string{"Element"}}, + {Name: "Left", Parents: []string{"Base"}}, + {Name: "Right", Parents: []string{"Base"}}, + {Name: "Leaf", Parents: []string{"Left", "Right"}}, + } + m, err := newModel(classes, nil, nil) + if err != nil { + t.Fatal(err) + } + want := []string{"Leaf", "Left", "Right", "Base", "Element"} + if got := strings.Join(m.mros["Leaf"], ","); got != strings.Join(want, ",") { + t.Fatalf("Leaf MRO = %v, want %v", m.mros["Leaf"], want) + } +} + +func TestGeneratorRejectsInvalidTables(t *testing.T) { + tests := []struct { + name string + classes []ontology.Class + properties []ontology.Property + enums []ontology.Enumeration + want string + }{ + { + name: "related property redeclaration", + classes: []ontology.Class{ + {Name: "Element"}, + {Name: "Parent", Parents: []string{"Element"}}, + {Name: "Child", Parents: []string{"Parent"}}, + }, + properties: []ontology.Property{ + testProperty("Parent", "feature"), + testProperty("Child", "feature"), + }, + want: "declared by related metaclasses", + }, + { + name: "duplicate snake name", + classes: []ontology.Class{ + {Name: "Element"}, + {Name: "Node", Parents: []string{"Element"}}, + }, + properties: []ontology.Property{ + testProperty("Node", "someName"), + testProperty("Node", "some_name"), + }, + want: "same Python name", + }, + { + name: "runtime member collision", + classes: []ontology.Class{ + {Name: "Element"}, + {Name: "Node", Parents: []string{"Element"}}, + }, + properties: []ontology.Property{testProperty("Node", "jsonId")}, + want: "collides with runtime member", + }, + { + name: "class body shadowing", + classes: []ontology.Class{ + {Name: "Element"}, + {Name: "Node", Parents: []string{"Element"}}, + }, + properties: []ontology.Property{testProperty("Node", "Mapping")}, + want: "shadows generated class-body name", + }, + { + name: "invalid enum literal", + classes: []ontology.Class{{Name: "Element"}}, + enums: []ontology.Enumeration{{Name: "Direction", Literals: []string{"bad-literal"}}}, + want: "does not produce a valid Python identifier", + }, + { + name: "inconsistent C3 order", + classes: []ontology.Class{ + {Name: "Element"}, + {Name: "O"}, + {Name: "X", Parents: []string{"O"}}, + {Name: "Y", Parents: []string{"O"}}, + {Name: "A", Parents: []string{"X", "Y"}}, + {Name: "B", Parents: []string{"Y", "X"}}, + {Name: "Z", Parents: []string{"A", "B"}}, + }, + want: "C3 linearization failed", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + _, err := generate(tt.classes, tt.properties, tt.enums, "version", "tag", "commit") + if err == nil || !strings.Contains(err.Error(), tt.want) { + t.Fatalf("generate error = %v, want substring %q", err, tt.want) + } + }) + } +} + +func TestSnakeCasePreservesAcronymsAndDigits(t *testing.T) { + for input, want := range map[string]string{ + "ownedFeature": "owned_feature", + "XMLValue": "xml_value", + "part2D": "part2_d", + "in": "in_", + } { + if got := toSnake(input); got != want { + t.Errorf("toSnake(%q) = %q, want %q", input, got, want) + } + } +} + +func testProperty(class, name string) ontology.Property { + return ontology.Property{ + Name: name, DefiningClass: class, Kind: ontology.DatatypeProperty, + Range: xsdNS + "string", + } +}