@memoarchitect/ontology 0.4.4

package/src/architecture/functions/memo_functions.sysml

@@ -0,0 +1,30 @@
+package memo_architecture_functions {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    part def LogicalFunction specializes ArchitectureElement {
+        attribute functionCategory : String;
+        attribute trigger : String;
+        attribute outputSummary : String;
+        attribute concernKind : ConcernKind;
+        attribute criticality : CriticalityKind;
+    }
+    part def LogicalFlow specializes ArchitectureElement {
+        attribute flowKind : FlowKind;
+        attribute direction : DirectionKind;
+        attribute latencyBudgetMs : Real;
+        attribute staleAfterMs : Real;
+        attribute integrityLevel : String;
+    }
+    part def DataDefinition specializes ExchangeItem {
+        attribute confidentialityClass : String;
+        attribute integrityClass : String;
+        attribute availabilityClass : String;
+    }
+    part def ControlDefinition specializes ExchangeItem {
+        attribute controlType : String;
+        attribute timeoutMs : Real;
+        attribute retryPolicy : String;
+    }
+}

package/src/architecture/hardware_structure/memo_hardware_structure.sysml

@@ -0,0 +1,15 @@
+package memo_architecture_hardware_structure {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    part def HardwareAssembly specializes ArchitectureElement {
+        attribute responsibility : String;
+        attribute safetyRole : String;
+        attribute partNumber : String;
+        attribute mtbfHours : String;
+        attribute protectionClass : String;
+        attribute ipRating : String;
+        attribute lifecycleState : LifecycleStateKind;
+    }
+}

package/src/architecture/interfaces/memo_interfaces.sysml

@@ -0,0 +1,103 @@
+package memo_architecture_interfaces {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    // ─── Interface taxonomy ──────────────────────────────────────────
+    // One root `Interface`, specialized by realization domain
+    // (hardware / software) then by signaling family then by concrete
+    // protocol. The Arcadia layer (operational/system/logical/physical)
+    // is carried as the `arcadiaLayer` attribute, not as a type branch.
+
+    part def Interface specializes InterfaceElement {
+        attribute arcadiaLayer : ArcadiaLayerKind;
+        attribute interfaceKind : InterfaceKind;
+        attribute direction : DirectionKind;
+        attribute protocol : String;
+        attribute protocolSemantics : String;
+        attribute interactionPattern : String;
+    }
+
+    // ─── Hardware interfaces ─────────────────────────────────────────
+
+    part def HardwareInterface specializes Interface {
+        attribute electricalStandard : String;
+        attribute nominalVoltageV : Real;
+        attribute nominalCurrentA : Real;
+        attribute directionality : DirectionKind;
+        attribute bandwidth : String;
+        attribute timingConstraint : String;
+    }
+
+    part def DigitalInterface specializes HardwareInterface {
+        attribute bitRateBps : String;
+        attribute signaling : String;
+    }
+    part def SPIInterface specializes DigitalInterface;
+    part def USBInterface specializes DigitalInterface;
+    part def I2CInterface specializes DigitalInterface;
+    part def CANInterface specializes DigitalInterface;
+    part def UARTInterface specializes DigitalInterface;
+    part def EthernetInterface specializes DigitalInterface;
+
+    part def AnalogInterface specializes HardwareInterface {
+        attribute signalRange : String;
+    }
+    part def VoltageInterface specializes AnalogInterface;
+    part def CurrentInterface specializes AnalogInterface;
+    part def CurrentLoop4To20mA specializes AnalogInterface;
+    part def ThermocoupleInterface specializes AnalogInterface;
+
+    // ─── Software interfaces ─────────────────────────────────────────
+
+    part def SoftwareInterface specializes Interface {
+        attribute apiStyle : String;
+    }
+
+    part def SynchronousInterface specializes SoftwareInterface;
+    part def RestInterface specializes SynchronousInterface;
+    part def GrpcInterface specializes SynchronousInterface;
+    part def RpcInterface specializes SynchronousInterface;
+    part def LocalApiInterface specializes SynchronousInterface;
+
+    part def AsynchronousInterface specializes SoftwareInterface;
+    part def MessageQueueInterface specializes AsynchronousInterface;
+    part def PubSubInterface specializes AsynchronousInterface;
+    part def EventStreamInterface specializes AsynchronousInterface;
+
+    // ─── Ports, interface defs, and exchanges ────────────────────────
+    // SysML port/interface mechanism + logical exchange, relocated here
+    // from the former logical_interfaces namespace.
+
+    abstract interface def DataInterface specializes InterfaceElement {
+        attribute interfaceKind : InterfaceKind;
+        attribute protocolSemantics : String;
+    }
+    port def DataPort {
+        attribute direction : DirectionKind;
+        attribute interfaceType : String;
+    }
+    port def SensorPort specializes DataPort { attribute sensorDomain : String; }
+    port def CommandPort specializes DataPort { attribute commandDomain : String; }
+
+    part def ComponentExchange specializes ArchitectureElement {
+        attribute exchangeKind : FlowKind;
+        attribute sourcePort : String;
+        attribute targetPort : String;
+        attribute allocatedFunctionalExchanges : String;
+        attribute direction : DirectionKind;
+        // Connection timing discipline from the source architecture
+        // (e.g. AADL Communication_Properties::Timing — immediate
+        // connections deliver in the same execution step).
+        attribute timingSemantics : String;
+    }
+    // Boundary data port of a software system (e.g. an AADL top-level
+    // data port), modeled as a first-class element so exchanges can
+    // reference it and views can render the system boundary.
+    part def SoftwarePort specializes InterfaceElement {
+        attribute portKind : InterfaceKind;
+        attribute direction : DirectionKind;
+        attribute dataTypeName : String;
+    }
+}

package/src/architecture/logical_structure/memo_logical_structure.sysml

@@ -0,0 +1,10 @@
+package memo_architecture_logical_structure {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    part def LogicalComponent specializes ArchitectureElement {
+        attribute responsibility : String;
+        attribute decompositionLevel : String;
+        attribute safetyPartition : String;
+    }
+}

package/src/architecture/operational/memo_operational.sysml

@@ -0,0 +1,51 @@
+package memo_architecture_operational {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    part def OperationalEntity specializes ArchitectureElement {
+        attribute entityKind : OperationalEntityKind;
+        attribute operationalDomain : String;
+        attribute responsibility : String;
+    }
+    part def OperationalActivity specializes ArchitectureElement {
+        attribute trigger : String;
+        attribute preCondition : String;
+        attribute postCondition : String;
+        attribute criticality : CriticalityKind;
+    }
+    part def OperationalCapability specializes ArchitectureElement {
+        attribute capabilityLevel : String;
+        attribute preCondition : String;
+        attribute postCondition : String;
+    }
+    part def OperationalScenario specializes TraceableElement {
+        attribute scenarioKind : ScenarioKind;
+        attribute preCondition : String;
+        attribute postCondition : String;
+        attribute sequenceDescription : String;
+    }
+    part def OperationalInteraction specializes ArchitectureElement {
+        attribute exchangeKind : FlowKind;
+        attribute direction : DirectionKind;
+        attribute latencyConstraint : String;
+    }
+
+    connection def Performs :> SemanticLink {
+        end entity : OperationalEntity;
+        end activity : OperationalActivity;
+    }
+    connection def ContributesToCapability :> SemanticLink {
+        end activity : OperationalActivity;
+        end capability : OperationalCapability;
+    }
+    connection def SequencesStep :> SemanticLink {
+        end activity : OperationalActivity;
+        end nextActivity : OperationalActivity;
+    }
+    connection def DerivesSystemNeed :> SemanticLink {
+        end activity : OperationalActivity;
+        end systemNeed : VerifiableElement;
+    }
+}

package/src/architecture/physical/memo_physical_architecture.sysml

@@ -0,0 +1,19 @@
+package memo_architecture_physical {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    part def ProcessingNode specializes ArchitectureElement {
+        attribute nodeKind : ProcessingNodeKind;
+        attribute processorArchitecture : String;
+        attribute memoryMB : String;
+        attribute operatingSystem : String;
+        attribute safetyPartition : Boolean;
+        attribute redundancyKind : String;
+    }
+    part def PhysicalPort specializes InterfaceElement {
+        attribute portKind : InterfaceKind;
+        attribute connectorType : String;
+        attribute direction : DirectionKind;
+    }
+}

package/src/architecture/requirements/memo_requirements.sysml

@@ -0,0 +1,69 @@
+package memo_architecture_requirements {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    requirement def StakeholderNeed specializes RequirementDriver {
+        attribute statement : String;
+        attribute priority : String;
+    }
+    part def RiskDriver specializes RequirementDriver { attribute driverKind : String; }
+    requirement def Requirement specializes VerifiableElement {
+        attribute statement : String;
+        attribute sourceKind : RequirementSourceKind;
+        attribute concernKind : ConcernKind;
+        attribute status : RequirementStatusKind;
+        attribute acceptanceCriteria : String;
+        attribute subjectDescription : String;
+        attribute actorDescription : String;
+        attribute assumptionSummary : String;
+        attribute guaranteeSummary : String;
+        // Authoring notation. `notation` selects the syntactic discipline the
+        // `statement` follows; the slot attributes below carry the parsed clauses
+        // so tools can lint pattern conformance and render either style.
+        attribute notation : RequirementNotationKind;
+        attribute earsPattern : EarsPatternKind;   // applies when notation = ears
+        attribute obligation : ObligationKind;      // shall/should/will (RFC 2119, SOPHIST legal-obligation)
+        attribute conditionClause : String;         // EARS When/While/If/Where or SOPHIST condition clause
+        attribute systemResponse : String;          // the "shall <system response>" predicate
+    }
+    requirement def SystemRequirement specializes Requirement;
+    requirement def SoftwareRequirement specializes Requirement { attribute safetyClass : SafetyClassKind; }
+    requirement def HardwareRequirement specializes Requirement { attribute electricalSafetyRelevant : Boolean; }
+    requirement def DesignControlNeed specializes StakeholderNeed {
+        attribute sourceFolder : String;
+        attribute linkedDesignControls : String;
+    }
+    requirement def DesignControlSpecification specializes Requirement {
+        attribute specificationDomain : String;
+        attribute sourceFolder : String;
+        attribute linkedUserNeeds : String;
+        attribute linkedRisks : String;
+        attribute linkedTests : String;
+    }
+    requirement def HardwareSpecification specializes DesignControlSpecification;
+    requirement def SoftwareSpecification specializes DesignControlSpecification {
+        attribute softwareSafetyClass : SafetyClassKind;
+    }
+    requirement def SystemSpecification specializes DesignControlSpecification;
+    // Named constant defined by a source requirements document (e.g. CriSys
+    // GPCA App. A.4) and referenced from requirement statements.
+    part def SystemConstant specializes TraceableElement {
+        attribute symbol : String;          // identifier as written in the source, e.g. "Tolerance_Max const"
+        attribute unit : String;
+        attribute valueType : String;
+        attribute constantValue : String;   // empty when the source leaves the value open
+        attribute valueCondition : String;  // constraints on the value stated by the source
+    }
+    // One row of a notification/alarm action table (e.g. CriSys GPCA REQ 59):
+    // a named notification, its priority, and the actions the system must take.
+    part def NotificationSpec specializes TraceableElement {
+        attribute priority : NotificationPriorityKind;
+        attribute visualNotification : Boolean;
+        attribute audioNotification : Boolean;
+        attribute inhibitInfusion : Boolean;
+        attribute inhibitSquareBolus : Boolean;
+        attribute inhibitPatientBolus : Boolean;
+        attribute stopBolus : Boolean;
+    }
+}

package/src/architecture/risk/memo_arch_risk.sysml

@@ -0,0 +1,7 @@
+package memo_architecture_risk_arch_risk {
+    private import ScalarValues::*;
+
+    doc /* Configuration Item (CI) aggregator for MEMO architecture risk domain.
+         * Re-exports all risk-related packages for Sysand build. */
+    public import memo_architecture_risk_risk::*;
+}

package/src/architecture/risk/memo_risk.sysml

@@ -0,0 +1,80 @@
+package memo_architecture_risk_risk {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_architecture_requirements::*;
+    part def Risk specializes RiskDriver {
+        attribute probabilityEstimate : ProbabilityKind;
+        attribute severityEstimate : SeverityKind;
+        attribute riskLevel : CriticalityKind;
+        attribute acceptability : RiskAcceptabilityKind;
+    }
+    part def RiskBeforeMitigation specializes Risk {
+        attribute estimationBasis : String;
+        attribute analysisContext : String;
+        attribute foreseeableMisuseIncluded : Boolean;
+    }
+    part def RiskAfterMitigation specializes Risk {
+        attribute residualProbability : ProbabilityKind;
+        attribute residualSeverity : SeverityKind;
+        attribute residualAcceptability : RiskAcceptabilityKind;
+        attribute benefitRiskRequired : Boolean;
+    }
+    part def RiskMatrix specializes TraceableElement {
+        attribute probabilityScaleDefinition : String;
+        attribute severityScaleDefinition : String;
+        attribute riskLevelMapping : String;
+        attribute acceptabilityThresholds : String;
+    }
+    part def DesignControlRiskRow specializes Risk {
+        attribute rowTitle : String;
+        attribute hazardAnalysis : String;
+        attribute hazardCategory : String;
+        attribute hazardSubcategory : String;
+        attribute causeSequenceOfEventsFailure : String;
+        attribute harmText : String;
+        attribute probabilityBeforeRaw : String;
+        attribute severityBeforeRaw : String;
+        attribute riskBeforeMeasureRaw : String;
+        attribute probabilityAfterRaw : String;
+        attribute severityAfterRaw : String;
+        attribute riskAfterMitigationRaw : String;
+        attribute cannotReduceFurther : Boolean;
+        attribute linkSummary : String;
+    }
+    item def Hazard specializes TraceableElement {
+        attribute hazardType : HazardTypeKind;
+        attribute severity : SeverityKind;
+        attribute foreseeable : Boolean;
+    }
+    item def SequenceOfEvents specializes TraceableElement {
+        attribute initiatingEvent : String;
+        attribute contributingFactors : String;
+    }
+    // A categorized root cause in a hazard causal tree (FDA GIIP
+    // taxonomy pattern: cause -> hazard -> hazardous situation -> harm;
+    // several HazardCause elements may converge on one Hazard).
+    item def HazardCause specializes TraceableElement {
+        attribute causeSource : CauseSourceKind;
+        attribute contributingFactors : String;
+    }
+    item def HazardousSituation specializes TraceableElement {
+        attribute exposedPersons : String;
+        attribute operatingCondition : String;
+    }
+    item def Harm specializes TraceableElement {
+        attribute clinicalImpact : String;
+        attribute reversibility : String;
+        attribute severity : SeverityKind;
+    }
+    item def RiskControl specializes VerifiableElement {
+        attribute controlKind : RiskControlKind;
+        attribute implementationKind : RiskControlImplementationKind;
+        attribute verificationStatus : String;
+    }
+    item def OverallResidualRiskEvaluation specializes TraceableElement {
+        attribute conclusion : String;
+        attribute reviewer : String;
+    }
+}

package/src/architecture/software_structure/memo_software_structure.sysml

@@ -0,0 +1,44 @@
+package memo_architecture_software_structure {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    part def SoftwareSystem specializes ArchitectureElement {
+        attribute version : String;
+        attribute lifecycleState : LifecycleStateKind;
+        attribute safetyClass : SafetyClassKind;
+        attribute complexity : ComplexityKind;
+        attribute operatingSystem : String;
+    }
+    part def SoftwareComponent specializes ArchitectureElement {
+        attribute responsibility : String;
+        attribute safetyClass : SafetyClassKind;
+        attribute complexity : ComplexityKind;
+        attribute periodMs : Real;
+        attribute deadlineMs : Real;
+        attribute wcetMs : Real;
+        attribute schedulingPolicy : SchedulingPolicyKind;
+    }
+    part def SoftwareItem specializes SoftwareComponent {
+        attribute softwareItemKind : String;
+        attribute iec62304Role : String;
+    }
+    part def FirmwareItem specializes SoftwareItem {
+        attribute firmwareTarget : String;
+        attribute updateMechanism : String;
+    }
+    part def SOUPComponent specializes SoftwareComponent {
+        attribute soupVersion : String;
+        attribute soupVendor : String;
+        attribute knownAnomalies : String;
+        attribute riskAcceptance : String;
+        attribute classification : SOUPClassificationKind;
+    }
+    item def SBOMEntry specializes TraceableElement {
+        attribute componentName : String;
+        attribute version : String;
+        attribute supplier : String;
+        attribute license : String;
+        attribute hash : String;
+    }
+}

package/src/architecture/system/memo_system_analysis.sysml

@@ -0,0 +1,54 @@
+package memo_architecture_system {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_functions::*;
+    part def SystemCapability specializes ArchitectureElement {
+        attribute capabilityKind : String;
+        attribute primaryFunction : String;
+        attribute safetyRelevant : Boolean;
+    }
+    part def FunctionalChain specializes ArchitectureElement {
+        attribute chainKind : FunctionalChainKind;
+        attribute startFunction : String;
+        attribute endFunction : String;
+        attribute endToEndLatencyBudgetMs : String;
+        attribute safetyRelevant : Boolean;
+        attribute securityRelevant : Boolean;
+    }
+    part def FunctionalChainStep specializes TraceableElement {
+        attribute stepOrder : String;
+        attribute allocatedFunction : String;
+        attribute exchangeItem : String;
+    }
+    part def SystemScenario specializes TraceableElement {
+        attribute scenarioKind : ScenarioKind;
+        attribute sequenceDiagramRef : String;
+        attribute precondition : String;
+        attribute postcondition : String;
+    }
+    part def Mission specializes DocumentedElement {
+        attribute missionKind : String;
+        attribute successCriteria : String;
+        attribute operationalContext : String;
+    }
+
+    connection def RealizesCapability :> SemanticLink {
+        end functionalChain : FunctionalChain;
+        end capability : SystemCapability;
+    }
+    connection def IncludesStep :> SemanticLink {
+        end functionalChain : FunctionalChain;
+        end step : FunctionalChainStep;
+    }
+    connection def InvolvesFunction :> SemanticLink {
+        end functionalChain : FunctionalChain;
+        end function : LogicalFunction;
+    }
+    connection def RealizesScenario :> SemanticLink {
+        end functionalChain : FunctionalChain;
+        end scenario : SystemScenario;
+    }
+}

package/src/artifacts/clinical_safety_report.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_clinical_safety_report {
+    private import ScalarValues::*;
+
+            private import memo_artifacts_definitions::*;
+            private import memo_core_enumerations::*;
+
+            part def ClinicalSafetyReport specializes ArtifactKindDef {
+    attribute :>> documentTitle = "Clinical Safety Report";
+    attribute :>> regulatoryRef = "ISO 14971:2019 §10";
+    attribute :>> artifactKind = ArtifactKind::clinicalSafetyReport;
+            }
+}

package/src/artifacts/cybersecurity_assessment_report.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_cybersecurity_assessment_report {
+    private import ScalarValues::*;
+
+            private import memo_artifacts_definitions::*;
+            private import memo_core_enumerations::*;
+
+            part def CybersecurityAssessmentReport specializes ArtifactKindDef {
+    attribute :>> documentTitle = "Cybersecurity Risk Assessment";
+    attribute :>> regulatoryRef = "FDA Cybersecurity Guidance";
+    attribute :>> artifactKind = ArtifactKind::cybersecurityAssessment;
+            }
+}

package/src/artifacts/definitions/memo_artifact_definitions.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_definitions {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    part def ArtifactKindDef specializes TraceableElement {
+        attribute documentTitle : String;
+        attribute regulatoryRef : String;
+        attribute artifactKind : ArtifactKind;
+    }
+}

package/src/artifacts/design_change_log.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_design_change_log {
+    private import ScalarValues::*;
+
+            private import memo_artifacts_definitions::*;
+            private import memo_core_enumerations::*;
+
+            part def DesignChangeLog specializes ArtifactKindDef {
+    attribute :>> documentTitle = "Design Change Log";
+    attribute :>> regulatoryRef = "ISO 13485:2016 §7.3.9";
+    attribute :>> artifactKind = ArtifactKind::designChangeLog;
+            }
+}

package/src/artifacts/design_history_file_index.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_design_history_file_index {
+    private import ScalarValues::*;
+
+            private import memo_artifacts_definitions::*;
+            private import memo_core_enumerations::*;
+
+            part def DesignHistoryFileIndex specializes ArtifactKindDef {
+    attribute :>> documentTitle = "Design History File Index";
+    attribute :>> regulatoryRef = "ISO 13485:2016 §4.2.4 / 21 CFR 820.30";
+    attribute :>> artifactKind = ArtifactKind::designHistoryFileIndex;
+            }
+}

package/src/artifacts/design_input_plan.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_design_input_plan {
+    private import ScalarValues::*;
+
+            private import memo_artifacts_definitions::*;
+            private import memo_core_enumerations::*;
+
+            part def DesignInputPlan specializes ArtifactKindDef {
+    attribute :>> documentTitle = "Design Input Plan";
+    attribute :>> regulatoryRef = "ISO 13485:2016 §7.3.3";
+    attribute :>> artifactKind = ArtifactKind::designInputPlan;
+            }
+}

package/src/artifacts/design_output_plan.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_design_output_plan {
+    private import ScalarValues::*;
+
+            private import memo_artifacts_definitions::*;
+            private import memo_core_enumerations::*;
+
+            part def DesignOutputPlan specializes ArtifactKindDef {
+    attribute :>> documentTitle = "Design Output Plan";
+    attribute :>> regulatoryRef = "ISO 13485:2016 §7.3.4";
+    attribute :>> artifactKind = ArtifactKind::designOutputPlan;
+            }
+}

package/src/artifacts/evidence_record.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_evidence_record {
+    private import ScalarValues::*;
+
+            private import memo_artifacts_definitions::*;
+            private import memo_core_enumerations::*;
+
+            part def EvidenceRecord specializes ArtifactKindDef {
+    attribute :>> documentTitle = "Evidence Record";
+    attribute :>> regulatoryRef = "21 CFR 820.30";
+    attribute :>> artifactKind = ArtifactKind::evidenceRecord;
+            }
+}

package/src/artifacts/failure_mode_effects_analysis.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_failure_mode_effects_analysis {
+    private import ScalarValues::*;
+
+            private import memo_artifacts_definitions::*;
+            private import memo_core_enumerations::*;
+
+            part def FailureModeEffectsAnalysisReport specializes ArtifactKindDef {
+    attribute :>> documentTitle = "Failure Mode and Effects Analysis";
+    attribute :>> regulatoryRef = "IEC 60812:2018";
+    attribute :>> artifactKind = ArtifactKind::failureModeEffectsAnalysis;
+            }
+}

package/src/artifacts/hazard_analysis_report.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_hazard_analysis_report {
+    private import ScalarValues::*;
+
+            private import memo_artifacts_definitions::*;
+            private import memo_core_enumerations::*;
+
+            part def HazardAnalysisReport specializes ArtifactKindDef {
+    attribute :>> documentTitle = "Hazard Analysis Report";
+    attribute :>> regulatoryRef = "ISO 14971:2019 §5-6";
+    attribute :>> artifactKind = ArtifactKind::riskRecord;
+            }
+}

package/src/artifacts/labeling_specification.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_labeling_specification {
+    private import ScalarValues::*;
+
+            private import memo_artifacts_definitions::*;
+            private import memo_core_enumerations::*;
+
+            part def LabelingSpecification specializes ArtifactKindDef {
+    attribute :>> documentTitle = "Labeling Specification";
+    attribute :>> regulatoryRef = "21 CFR 801 / MDR Annex I §23";
+    attribute :>> artifactKind = ArtifactKind::labelingSpecification;
+            }
+}

package/src/artifacts/requirements_specification.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_requirements_specification {
+    private import ScalarValues::*;
+
+            private import memo_artifacts_definitions::*;
+            private import memo_core_enumerations::*;
+
+            part def RequirementsSpecification specializes ArtifactKindDef {
+    attribute :>> documentTitle = "Requirements Specification";
+    attribute :>> regulatoryRef = "ISO 13485:2016 §7.3.3";
+    attribute :>> artifactKind = ArtifactKind::requirementSpecification;
+            }
+}