@memoarchitect/ontology 0.4.5 → 0.6.0

package/src/core/dimensions/dimensions.sysml

@@ -1,37 +1,58 @@
-// Multi-valued attributes collapsed to scalar pending grammar extension (ADR-1-16).
-// Bare import (no `private`) per ADR-1-16 fallback.
+// Lifecycle and cross-cutting classification dimensions.
+//
+// Axis ownership (horizontal architecture layer vs. vertical assurance
+// discipline) is NOT a tag here — it is encoded by package membership: every
+// element is defined in exactly one axis package (memo_architecture_* xor
+// memo_assurance_*), enforced by CR-ONT-045. The remaining dimensions below
+// (realization stage, cross-cutting concern, element status) are genuinely
+// orthogonal to the axis and to each other, and stay as metadata.
 package memo_core_dimensions {
     private import ScalarValues::*;
 
-    private import memo_core_common::*;
-
-    enum def DimensionKind {
-        enum architecture;
-        enum compliance;
-        enum artifact;
-        enum viewpointType;
-    }
-
-    part def ElementKind specializes TraceableElement {
-        attribute kindName : String;
-        attribute primaryDimension : DimensionKind;
+    // Realization stages of one element identity across the product
+    // lifecycle (specification through retirement). Orthogonal to the axis:
+    // a single identity progresses through stages without changing its owner.
+    enum def RealizationStageKind {
+        enum specified;
+        enum designed;
+        enum built;
+        enum configured;
+        enum assembled;
+        enum deployed;
+        enum operated;
+        enum retired;
     }
 
-    part def ArchitectureElementKind specializes ElementKind {
-        attribute archLayer : String;
+    // Cross-cutting concerns orthogonal to the axis.
+    enum def CrossCuttingConcernKind {
+        enum evidence;
+        enum traceability;
+        enum configurationManagement;
+        enum changeControl;
+        enum regulatoryCompliance;
+        enum clinicalPerformance;
     }
 
-    part def ComplianceElementKind specializes ElementKind {
-        attribute standardReference : String;
-        attribute clause : String;
+    // Editorial status of the model element itself (distinct from the
+    // lifecycle of the thing the element describes).
+    enum def ElementStatusKind {
+        enum draft;
+        enum inReview;
+        enum approved;
+        enum released;
+        enum deprecated;
+        enum retired;
     }
 
-    part def ArtifactElementKind specializes ElementKind {
-        attribute documentTitle : String;
-        attribute regulatoryReference : String;
+    // Metadata carriers for tagging non-part constructs (actions, ports,
+    // interfaces, items, views) with the orthogonal dimensions. Part-based
+    // elements carry these directly as attributes of MemoPart. Axis ownership
+    // is never tagged here — it is the construct's owning package.
+    metadata def RealizationClassification {
+        attribute stage : RealizationStageKind[0..1];
     }
 
-    part def ViewpointTypeKind specializes ElementKind {
-        attribute typeId : String;
+    metadata def CrossCuttingClassification {
+        attribute crossCutting : CrossCuttingConcernKind[0..*];
     }
 }

package/src/core/enumerations/memo_enumerations.sysml

@@ -54,12 +54,6 @@ package memo_core_enumerations {
         enum should;
         enum will;
     }
-    enum def ArcadiaLayerKind {
-        enum operational;
-        enum system;
-        enum logical;
-        enum physical;
-    }
     enum def InterfaceKind {
         enum data;
         enum control;
@@ -227,6 +221,16 @@ package memo_core_enumerations {
         enum assumption;
         enum guarantee;
     }
+    enum def InterfaceItemKind {
+        enum data;
+        enum command;
+        enum signal;
+        enum event;
+        enum material;
+        enum energy;
+        enum fluid;
+        enum mechanicalForce;
+    }
     enum def PropertyLanguageKind {
         enum naturalLanguage;
         enum pseudoFormal;
@@ -370,16 +374,7 @@ package memo_core_enumerations {
         enum device;
         enum informationArtifact;
     }
-    enum def ScenarioKind {
-        enum nominal;
-        enum degraded;
-        enum emergency;
-        enum maintenance;
-        enum error;
-        enum timeout;
-        enum alarm;
-    }
-    enum def FunctionalChainKind {
+    enum def FunctionalFlowKind {
         enum nominal;
         enum error;
         enum degraded;

package/src/core/methodology_scope/methodology_scope.sysml

@@ -1,44 +1,26 @@
-// Methodology scope helpers per Epic B-3.
-// Multi-valued attributes collapsed to scalar pending grammar extension (ADR-1-15).
-// Bare imports (no `private`) per ADR-1-16 fallback.
-// Instances use repeated scalar attribute usages to enumerate set entries
-// (see ADR-1-15 example: `attribute :>> includedArchLayer = "operational";`).
+// Methodology scope helpers.
+// Instances use repeated scalar attribute usages to enumerate set entries, for
+// example: `attribute :>> includedArchLayer = "operational";`.
 package memo_core_methodology_scope {
     private import ScalarValues::*;
 
     private import memo_core_common::*;
     private import memo_core_dimensions::*;
 
-    part def MethodologyLayerSet specializes TraceableElement {
+    part def MethodologyLayerSet specializes MemoPart {
         attribute setName : String;
         attribute layer : String;
     }
 
-    part def MethodologyStandardSet specializes TraceableElement {
-        attribute setName : String;
-        attribute standardReference : String;
-    }
-
-    part def MethodologyArtifactSet specializes TraceableElement {
-        attribute setName : String;
-        attribute artifactKind : String;
-    }
-
-    part def MethodologyViewpointTypeSet specializes TraceableElement {
-        attribute setName : String;
-        attribute viewpointType : String;
-    }
-
-    part def MethodologyScope specializes TraceableElement {
+    part def MethodologyScope specializes MemoPart {
         attribute scopeName : String;
-        attribute includedArchLayer : String;
-        attribute includedStandard : String;
-        attribute includedArtifactKind : String;
-        attribute includedViewpointType : String;
-        attribute excludedKind : String;
+        attribute includedArchLayer : String[0..*];
+        // Qualified package names may resolve to MEMO, project, supplier, or
+        // other externally provided ontology modules.
+        attribute includedModule : String[0..*];
     }
 
-    part def ElementKindAlias specializes TraceableElement {
+    part def ElementKindAlias specializes MemoPart {
         attribute methodTerm : String;
         attribute concreteKind : String;
         attribute concreteOntology : String;

package/src/core/relationships/memo_relationships.sysml

@@ -5,225 +5,257 @@ package memo_core_relationships {
     private import memo_core_enumerations::*;
 
     // All MEMO relations are native SysML v2 `connection def`s (each is a
-    // Connection/Association), specializing the SemanticLink base. The
+    // Connection/Association), specializing the MemoRelationship base. The
     // relationship name is the verb; the RelationshipRegistry derives the
     // navigable type as camelCase(name) and navigation is bidirectional.
-    abstract connection def SemanticLink { attribute linkStatus : LinkStatusKind; }
+    // Structural properties of a relation, declared here so authoring and
+    // validation read them from the ontology instead of assuming them. Both are
+    // unset on the base and carry the conservative reading: a relation forbids
+    // self-links and forbids repeats unless it says otherwise. A subtype opts
+    // out by redefining, e.g. `attribute :>> isReflexive = true;`.
+    abstract connection def MemoRelationship {
+        attribute linkStatus : LinkStatusKind;
+        doc /* True when an element may be related to itself by this relation.
+             * Unset is read as false. */
+        attribute isReflexive : Boolean;
+        doc /* True when at most one link of this type may join the same ordered
+             * pair of elements — KerML Feature::isUnique over the relation.
+             * Unset is read as true. */
+        attribute isUnique : Boolean;
+    }
+
+    // The general relation that can join any two model elements, whatever
+    // their metaclass. Most specific relations type their ends against a
+    // foundation (MemoPart, VerifiableElement, …). A small number of specific
+    // cross-metaclass relations leave an end untyped because their accepted
+    // constructs have no shared MEMO base; their names and attributes still
+    // carry a precise engineering meaning. MemoLink leaves both ends untyped
+    // and adds no domain-specific semantics, which is what makes it universal.
+    //
+    // It is deliberately the weakest relation in the ontology. Reach for it
+    // only when no specific relation carries the meaning, and say why in
+    // linkRationale — an untyped link with no stated reason is an audit gap,
+    // not a model fact.
+    connection def MemoLink :> MemoRelationship {
+        doc /* Generic association between any two model elements. */
+        attribute linkRationale : String;
+        end linkSource;
+        end linkTarget;
+    }
 
-    connection def DerivesFrom :> SemanticLink {
+    connection def DerivesFrom :> MemoRelationship {
         // Drivers include needs and hazards (ISO 14971: hazards drive
-        // requirements), so the source stays at TraceableElement
-        end sourceDriver : TraceableElement;
+        // requirements), so the source stays at MemoPart
+        end sourceDriver : MemoPart;
         end targetRequirement : VerifiableElement;
     }
-    connection def SatisfiedBy :> SemanticLink {
+    connection def SatisfiedBy :> MemoRelationship {
         end requiredElement : VerifiableElement;
         end satisfyingElement : ArchitectureElement;
     }
-    connection def MitigatesHazard :> SemanticLink {
-        end riskControl : VerifiableElement;
-        end mitigatedHazard : TraceableElement;
-    }
-    connection def AllocatedTo :> SemanticLink {
+    // Mitigates unifies the control/action → risk-element edges of the
+    // ISO 14971 / FMEA / FTA / cyber chains — MitigatesHazard,
+    // MitigatesVulnerability, MitigatedByControl, BrokenByControl,
+    // AddressedByAction — keyed by mitigationKind. control is the mitigating
+    // control/action; mitigatedElement is the hazard/vulnerability/failure/cut set.
+    enum def MitigationKind {
+        enum hazard;
+        enum vulnerability;
+        enum failureMode;
+        enum cutSet;
+        enum fmeaAction;
+    }
+    connection def Mitigates :> MemoRelationship {
+        attribute mitigationKind : MitigationKind;
+        end control : VerifiableElement;
+        end mitigatedElement : MemoPart;
+    }
+    connection def AllocatedTo :> MemoRelationship {
         end function : ArchitectureElement;
         end allocatedElement : ArchitectureElement;
     }
-    connection def RealizesInterface :> SemanticLink {
-        end logicalInterface : InterfaceElement;
-        end physicalInterface : InterfaceElement;
-    }
-    connection def VerifiedBy :> SemanticLink {
+    // Realizes is the single realization relation (realizing/concrete element →
+    // realized/abstract element). It unifies RealizesInterface,
+    // RealizesComponentExchange, RealizedByArchitecture, RealizesScenario,
+    // ModuleRealizesLogical, ComponentRealizesModule, PhysicalModuleRealizesLogical,
+    // Implements{Component,Procedure}, UIRealizesFunctional,
+    // FunctionalRealizesOper{ative,ational} and ScenarioRealizesUseCase.
+    connection def Realizes :> MemoRelationship {
+        end realizing : MemoPart;
+        end realized : MemoPart;
+    }
+    connection def VerifiedBy :> MemoRelationship {
         // Requirements, risk controls, and architecture components are
         // all legitimate verification targets
-        end verificationTarget : TraceableElement;
-        end verificationCase : VerifiableElement;
+        end verificationTarget : MemoPart;
+        end verificationCase : MemoVerificationCase;
     }
-    connection def ProducesEvidence :> SemanticLink {
-        end producer : VerifiableElement;
-        end producedEvidence : EvidenceElement;
+    connection def ProducesEvidence :> MemoRelationship {
+        end producer : MemoVerificationCase;
+        end producedEvidence : MemoEvidence;
     }
-    connection def IncludedIn :> SemanticLink {
-        end sourceElement : TraceableElement;
-        end targetView : TraceableElement;
+    connection def IncludedIn :> MemoRelationship {
+        end sourceElement : MemoPart;
+        end targetView : MemoPart;
     }
-    connection def Precedes :> SemanticLink {
+    connection def Precedes :> MemoRelationship {
         attribute sameStepRequired : Boolean;
         attribute precedenceRationale : String;
         end predecessor : ArchitectureElement;
         end successor : ArchitectureElement;
     }
-    connection def ResolvesToMethodology :> SemanticLink {
-        end boundModelElement : TraceableElement;
-        end resolvedMethodology : TraceableElement;
+    connection def ResolvesToMethodology :> MemoRelationship {
+        end boundModelElement : MemoPart;
+        end resolvedMethodology : MemoPart;
     }
 
     // ISO 14971 risk chain — distinct sequence-of-events relations over risk elements.
-    connection def TracesRisk :> SemanticLink {
-        end sourceRiskElement : TraceableElement;
-        end targetRiskElement : TraceableElement;
+    connection def TracesRisk :> MemoRelationship {
+        end sourceRiskElement : MemoPart;
+        end targetRiskElement : MemoPart;
     }
-    connection def AssessedAgainst :> SemanticLink {
-        end risk : TraceableElement;
-        end riskMatrix : TraceableElement;
+    connection def AssessedAgainst :> MemoRelationship {
+        end risk : MemoPart;
+        end riskMatrix : MemoPart;
     }
 
-    connection def ThreatenedBy :> SemanticLink {
+    connection def ThreatenedBy :> MemoRelationship {
         attribute threatRole : String;
         end protectedAsset : ArchitectureElement;
         end realizedThreat : RequirementDriver;
     }
-    connection def Exploits :> SemanticLink {
+    connection def Exploits :> MemoRelationship {
         end realizedThreat : RequirementDriver;
-        end enablingVulnerability : TraceableElement;
+        end enablingVulnerability : MemoPart;
     }
-    connection def RealizedByScenario :> SemanticLink {
+    connection def RealizedByScenario :> MemoRelationship {
         end realizedThreat : RequirementDriver;
-        end scenario : TraceableElement;
-    }
-    connection def MitigatesVulnerability :> SemanticLink {
-        end enablingVulnerability : TraceableElement;
-        end mitigation : VerifiableElement;
+        end scenario : MemoPart;
     }
-    connection def DerivesCyberRequirement :> SemanticLink {
+    connection def DerivesCyberRequirement :> MemoRelationship {
         end sourceThreatOrRisk : RequirementDriver;
         end targetRequirement : VerifiableElement;
     }
-    connection def ImpactsSafety :> SemanticLink {
+    connection def ImpactsSafety :> MemoRelationship {
         attribute tracePurpose : String;
-        end cyberElement : TraceableElement;
-        end safetyElement : TraceableElement;
+        end cyberElement : MemoPart;
+        end safetyElement : MemoPart;
     }
-    connection def CrossesTrustBoundary :> SemanticLink {
+    connection def CrossesTrustBoundary :> MemoRelationship {
         attribute crossingKind : InterfaceKind;
         end boundary : InterfaceElement;
-        end crossingItem : TraceableElement;
+        end crossingItem : MemoPart;
     }
 
-    connection def DerivesInto :> SemanticLink {
-        end parentRequirement : VerifiableElement;
-        end childRequirement : VerifiableElement;
+    connection def Validates :> MemoRelationship {
+        // Validation targets include use cases and other behavioural elements,
+        // so the target remains untyped across SysML metaclass families.
+        end validationTarget;
+        end validationCase : MemoVerificationCase;
     }
-    connection def DeploysOnto :> SemanticLink {
-        attribute deploymentKind : DeploymentKind;
-        end softwareComponent : ArchitectureElement;
-        end hostAssembly : ArchitectureElement;
-    }
-    connection def Validates :> SemanticLink {
-        end validationTarget : VerifiableElement;
-        end validationCase : VerifiableElement;
-    }
-    connection def DependsOnSoup :> SemanticLink {
+    connection def DependsOnSoup :> MemoRelationship {
         end component : ArchitectureElement;
-        end soupItem : TraceableElement;
+        end soupItem : MemoPart;
     }
 
-    // Performs, ContributesToCapability, SequencesStep, DerivesSystemNeed
-    // (operational-entity ends) and RealizesCapability, InvolvesFunction,
-    // RealizesScenario (functional-chain ends) live in their owning
-    // architecture layer packages — memo::architecture::operational and
-    // memo::architecture::system respectively — because core must not
-    // depend on architecture-layer types. See memo_operational.sysml and
-    // memo_system_analysis.sysml.
+    // Performs unifies the former Performs / PerformsActivity / PerformsFunction
+    // synonyms. The performer (operational entity, actor, or system action) and
+    // the performed element (activity or function) are distinguished by the end
+    // instance types, so generic MemoPart ends keep this in core without a
+    // dependency on architecture-layer types.
+    connection def Performs :> MemoRelationship {
+        end performer : MemoPart;
+        end performed : MemoPart;
+    }
+
+    // Enables unifies the former EnablesWorkflow / EnablesActivity synonyms
+    // (an enabling system/function enables a workflow/activity).
+    connection def Enables :> MemoRelationship {
+        end enabling : MemoPart;
+        end enabled : MemoPart;
+    }
 
-    connection def HostedBy :> SemanticLink {
+    connection def HostedBy :> MemoRelationship {
         end processingNode : ArchitectureElement;
         end hostAssembly : ArchitectureElement;
     }
-    connection def RealizesComponentExchange :> SemanticLink {
-        end physicalLink : ArchitectureElement;
-        end componentExchange : ArchitectureElement;
-    }
 
-    connection def HasFailureMode :> SemanticLink {
+    connection def HasFailureMode :> MemoRelationship {
         end element : ArchitectureElement;
-        end failureMode : TraceableElement;
-    }
-    connection def CausesEffect :> SemanticLink {
-        end failureMode : TraceableElement;
-        end failureEffect : TraceableElement;
-    }
-    connection def CausedBy :> SemanticLink {
-        end failureMode : TraceableElement;
-        end failureCause : TraceableElement;
-    }
-    connection def DetectedBy :> SemanticLink {
-        end failureMode : TraceableElement;
-        end detectionMethod : TraceableElement;
-    }
-    connection def AddressedByAction :> SemanticLink {
-        end failureMode : TraceableElement;
-        end fmeaAction : VerifiableElement;
+        end failureMode : MemoPart;
+    }
+    // Causes unifies the former causal edges of the ISO 14971 / FMEA / FTA
+    // chains — CausesEffect, CausedBy, ContributesToHazard, LeadsToHazard,
+    // OriginatesFrom, UseErrorLeadsToHazard — keyed by causeKind. cause is the
+    // originating element, effect the consequence.
+    enum def CauseKind {
+        enum failureCausesEffect;
+        enum failureCausedBy;
+        enum contributesToHazard;
+        enum leadsToHazard;
+        enum originatesFrom;
+        enum useErrorLeadsToHazard;
+    }
+    connection def Causes :> MemoRelationship {
+        attribute causeKind : CauseKind;
+        end cause : MemoPart;
+        end effect : MemoPart;
+    }
+    connection def DetectedBy :> MemoRelationship {
+        end failureMode : MemoPart;
+        end detectionMethod : MemoPart;
     }
 
-    connection def InputToGate :> SemanticLink {
-        end input : TraceableElement;
-        end gate : TraceableElement;
-    }
-    connection def ProducesEvent :> SemanticLink {
-        end gate : TraceableElement;
-        end eventElement : TraceableElement;
+    connection def InputToGate :> MemoRelationship {
+        end input : MemoPart;
+        end gate : MemoPart;
     }
-    connection def OriginatesFrom :> SemanticLink {
-        end eventElement : TraceableElement;
-        end origin : ArchitectureElement;
+    connection def ProducesEvent :> MemoRelationship {
+        end gate : MemoPart;
+        end eventElement : MemoPart;
     }
-    connection def ContainsEvent :> SemanticLink {
-        end cutSet : TraceableElement;
-        end eventElement : TraceableElement;
+    connection def ContainsEvent :> MemoRelationship {
+        end cutSet : MemoPart;
+        end eventElement : MemoPart;
     }
 
-    connection def Decides :> SemanticLink {
-        end decision : TraceableElement;
-        end affectedElement : TraceableElement;
+    connection def Decides :> MemoRelationship {
+        end decision : MemoPart;
+        end affectedElement : MemoPart;
     }
 
-    connection def Composes :> SemanticLink {
-        end parent : ArchitectureElement;
-        end child : ArchitectureElement;
-    }
-    connection def AllocatesExchange :> SemanticLink {
-        end functionalFlow : ArchitectureElement;
-        end componentExchange : ArchitectureElement;
+    // Composes is the single whole/part decomposition relation. It unifies the
+    // former ComposesLogical / AssemblyComprises / Contains{Component,Element} /
+    // {Workflow,Task,Activity,Scenario}Comprises* / FlowComprisesSpec /
+    // Collection membership is carried by the end instance.
+    // types, so the ends are generic MemoPart.
+    connection def Composes :> MemoRelationship {
+        end parent : MemoPart;
+        end child : MemoPart;
     }
 
-    connection def ContributesToHazard :> SemanticLink {
-        end failureMode : TraceableElement;
-        end hazard : TraceableElement;
-    }
-    connection def LeadsToHazard :> SemanticLink {
-        end topEvent : TraceableElement;
-        end hazard : TraceableElement;
-    }
-    connection def IdentifiesHazard :> SemanticLink {
-        end deviation : TraceableElement;
-        end hazard : TraceableElement;
+    connection def IdentifiesHazard :> MemoRelationship {
+        end deviation : MemoPart;
+        end hazard : MemoPart;
     }
-    connection def AnalyzedBy :> SemanticLink {
+    connection def AnalyzedBy :> MemoRelationship {
         end element : ArchitectureElement;
-        end analysisArtifact : TraceableElement;
-    }
-    connection def MitigatedByControl :> SemanticLink {
-        end failureMode : TraceableElement;
-        end riskControl : VerifiableElement;
-    }
-    connection def BrokenByControl :> SemanticLink {
-        end cutSet : TraceableElement;
-        end riskControl : VerifiableElement;
+        end analysisArtifact : AnalysisArtifact;
     }
 
-    connection def Changes :> SemanticLink {
-        end changeRequest : TraceableElement;
-        end changedElement : TraceableElement;
+    connection def Changes :> MemoRelationship {
+        end changeRequest : MemoPart;
+        end changedElement : MemoPart;
     }
-    connection def TestedByUsability :> SemanticLink {
-        end uiElementOrTask : TraceableElement;
+    connection def TestedByUsability :> MemoRelationship {
+        end uiElementOrTask : MemoPart;
         end usabilityTest : VerifiableElement;
     }
-    connection def FeedsBackTo :> SemanticLink {
-        end feedbackItem : TraceableElement;
-        end designElement : TraceableElement;
+    connection def FeedsBackTo :> MemoRelationship {
+        end feedbackItem : MemoPart;
+        end designElement : MemoPart;
     }
-    connection def BindsToInterface :> SemanticLink {
+    connection def BindsToInterface :> MemoRelationship {
         end portElement : InterfaceElement;
         end boundInterface : InterfaceElement;
     }

package/src/core/stdlib/{collections.sysml → collections/collections.sysml}

@@ -1,4 +1,4 @@
-// Re-export-only wrapper per ADR-1-13. No new types.
+// Re-export-only wrapper. No new types.
 package memo_core_stdlib_collections {
     private import ScalarValues::*;
 

package/src/core/stdlib/{functions.sysml → functions/functions.sysml}

@@ -1,4 +1,4 @@
-// Re-export-only wrapper per ADR-1-13. No new types.
+// Re-export-only wrapper. No new types.
 package memo_core_stdlib_functions {
     private import ScalarValues::*;
 

package/src/core/stdlib/{scalars.sysml → scalars/scalars.sysml}

@@ -1,4 +1,4 @@
-// Re-export-only wrapper per ADR-1-13. No new types.
+// Re-export-only wrapper. No new types.
 package memo_core_stdlib_scalars {
     private import ScalarValues::*;
 

package/src/core/stdlib/{time.sysml → time/time.sysml}

@@ -1,4 +1,4 @@
-// Re-export-only wrapper per ADR-1-13. No new types.
+// Re-export-only wrapper. No new types.
 package memo_core_stdlib_time {
     private import ScalarValues::*;
 

package/src/core/terminology/terminology.sysml

@@ -0,0 +1,35 @@
+// Terminology and identification kernel. MEMO stays
+// terminology-neutral: any concept may carry several TerminologyCodes binding
+// it to SNOMED CT, GMDN, EMDN, UDI/GUDID, ISO/IEEE 11073 nomenclature, or a
+// local catalog — never a single ambiguous `code : String`.
+package memo_core_terminology {
+    private import ScalarValues::*;
+
+    // One coding of a concept in one code system. Mirrors the FHIR Coding
+    // datatype (system/version/code/display) so FHIR mappings stay lossless.
+    attribute def TerminologyCode {
+        attribute systemUri : String;
+        attribute code : String;
+        attribute display : String;
+        attribute codeSystemVersion : String;
+        attribute designation : String;
+    }
+
+    // A device-identity carrier per IMDRF UDI guidance: the DI portion
+    // belongs to the device definition, PI portions to the instance.
+    attribute def UdiCarrier {
+        attribute issuingAgency : String;
+        attribute deviceIdentifier : String;
+        attribute carrierHRF : String;
+        attribute carrierAIDC : String;
+    }
+
+    // A reference into an external registry or document (regulatory listing,
+    // standard clause, catalog page) with enough context to resolve it.
+    attribute def ExternalReference {
+        attribute referenceKind : String;
+        attribute identifier : String;
+        attribute uri : String;
+        attribute section : String;
+    }
+}