@memoarchitect/ontology 0.6.5 → 0.8.22

package/src/architecture/operational/workflows/memo_workflows.sysml

@@ -5,6 +5,7 @@
 // scenario. Workflows are action defs: steps, decisions, forks/joins, and
 // successions use native SysML v2 action semantics where portable.
 package memo_architecture_operational_workflows {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
 
     private import memo_core_common::*;
@@ -36,19 +37,18 @@ package memo_architecture_operational_workflows {
         attribute completionCondition : String;
         attribute recoveryPathSummary : String;
         attribute timingConstraints : String;
-        ref involvedActors : Actor[0..*];
+        ref involvedActors : OperationalParticipant[0..*];
         attribute environmentSummary : String;
     }
 
     // A step in a workflow wraps an operational activity or user task by
     // reference — the same activity may appear in several workflows.
     action def WorkflowStep specializes MemoAction {
-        attribute stepOrder : Integer;
         attribute entryCondition : String;
         attribute exitCondition : String;
         ref performedActivity : OperationalActivity[0..1];
         ref performedTask : UserTask[0..1];
-        ref responsibleRole : Actor[0..1];
+        ref responsibleRole : OperationalParticipant[0..1];
     }
 
     // decision / fork / join / handoff.
@@ -69,8 +69,8 @@ package memo_architecture_operational_workflows {
         attribute parallelismRationale : String[0..1];
         attribute joinCondition : String[0..1];
         attribute informationTransferred : String[0..1];
-        ref fromRole : Actor[0..1];
-        ref toRole : Actor[0..1];
+        ref fromRole : OperationalParticipant[0..1];
+        ref toRole : OperationalParticipant[0..1];
     }
 
     // Resources a workflow requires: information, materials, or equipment by
@@ -94,17 +94,24 @@ package memo_architecture_operational_workflows {
         // The accepted endpoints span SysML metaclasses: an operational
         // workflow or other action may support a use case, task, or
         // capability. They therefore have no single MEMO base type.
-        end supporter;
-        end supported;
+        end supporter :>> source;
+        end supported : MemoAction :>> target;
     }
-    connection def StepPrecedes :> MemoRelationship {
-        attribute guardCondition : String;
-        end predecessor : WorkflowStep;
-        end successor : WorkflowStep;
+    abstract connection supportsLinks : Supports[*];
+    metadata def <supports> SupportsMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = supportsLinks meta SysML::Usage;
     }
     connection def RequiresResource :> MemoRelationship {
-        end workflow : OperationalWorkflow;
-        end resource : WorkflowResource;
+        end workflow : OperationalWorkflow :>> source;
+        end resource : WorkflowResource :>> target;
+    }
+    abstract connection requiresResourceLinks : RequiresResource[*];
+    metadata def <requiresResource> RequiresResourceMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = requiresResourceLinks meta SysML::Usage;
     }
 
     // ── Workflow transformation (as-is → to-be) ──────────────────
@@ -119,8 +126,14 @@ package memo_architecture_operational_workflows {
         attribute transformKind : TransformKind;
         attribute transformation : StepTransformationKind[0..1];
         attribute transformationRationale : String[0..1];
-        end source : MemoPart;
-        end target : MemoPart;
+        end source : MemoAction;
+        end target : MemoAction;
+    }
+    abstract connection transformsLinks : Transforms[*];
+    metadata def <transforms> TransformsMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = transformsLinks meta SysML::Usage;
     }
     // The device or system whose introduction enables a workflow.
 }

package/src/architecture/realization/deployment/memo_deployment.sysml

@@ -1,18 +1,30 @@
-// Deployment (allocation) view: SoftwareModule buildsInto
-// DeploymentUnit; DeploymentUnit deploysTo ProcessingNode; SoftwareComponent
-// hostedBy ProcessingNode. Software deploys only to capable execution nodes
-// (rules/crosslayer).
+// Deployment (allocation) view: SoftwareModule buildsInto DeploymentUnit;
+// DeploymentUnit deploysTo ProcessingNode. Software deploys only to capable
+// execution nodes (rules/crosslayer).
+//
+// `HostedBy` is NOT part of that chain, and this comment used to claim it was
+// ("SoftwareComponent hostedBy ProcessingNode"). It is
+// `processingNode : ArchitectureElement -> hostAssembly : ArchitectureElement`:
+// physical hosting of a node by the assembly it is mounted in, running the
+// other way and between different things. Software reaches a node through
+// DeploysTo.
 package memo_architecture_realization_deployment {
+    private import Metaobjects::SemanticMetadata;
     private import ScalarValues::*;
+    // The standard's allocation base, which the two AADL bindings below root
+    // on alongside MemoRelationship.
+    private import Allocations::Allocation;
 
     private import memo_core_common::*;
     private import memo_core_enumerations::*;
     private import memo_core_relationships::*;
     private import memo_architecture_implementation_software_structure::*;
     private import memo_architecture_implementation_software_runtime::*;
+    private import memo_architecture_implementation_hardware_electrical::*;   // NetworkMedium
     private import memo_architecture_realization_physical::*;
     private import memo_architecture_functional_functions::*;
     private import memo_architecture_logical_structure::*;
+    private import memo_architecture_logical_interfaces::*;                   // ComponentExchange
 
     part def DeploymentUnit specializes ArchitectureElement {
         attribute unitKind : String;
@@ -29,17 +41,88 @@ package memo_architecture_realization_deployment {
     }
 
     connection def BuildsInto :> MemoRelationship {
-        end module : SoftwareModule;
-        end deploymentUnit : DeploymentUnit;
+        end module : SoftwareModule :>> source;
+        end deploymentUnit : DeploymentUnit :>> target;
+    }
+    abstract connection buildsIntoLinks : BuildsInto[*];
+    metadata def <buildsInto> BuildsIntoMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = buildsIntoLinks meta SysML::Usage;
     }
     connection def DeploysTo :> MemoRelationship {
         attribute deploymentKind : DeploymentKind;
-        end deploymentUnit : DeploymentUnit;
-        end node : ProcessingNode;
+        end deploymentUnit : DeploymentUnit :>> source;
+        end node : ProcessingNode :>> target;
+    }
+    abstract connection deploysToLinks : DeploysTo[*];
+    metadata def <deploysTo> DeploysToMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = deploysToLinks meta SysML::Usage;
     }
     connection def ProvidesEnvironment :> MemoRelationship {
-        end node : ProcessingNode;
-        end environment : RuntimeEnvironment;
+        end node : ProcessingNode :>> source;
+        end environment : RuntimeEnvironment :>> target;
+    }
+    abstract connection providesEnvironmentLinks : ProvidesEnvironment[*];
+    metadata def <providesEnvironment> ProvidesEnvironmentMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = providesEnvironmentLinks meta SysML::Usage;
+    }
+
+    // ─── AADL bindings (SAE AS5506) — plan C1 ────────────────────────────
+    //
+    // AADL's analytic power is that EVERYTHING is bound to something, and the
+    // binding is where latency, bandwidth and fault propagation accrue. MEMO
+    // had one binding of three: `DeploysTo` is `actual_processor_binding`.
+    // Without the other two, `SoftwareComponent.memoryBudget` is unanalysable
+    // and `EndToEndFlow.latencyBudgetMs` cannot be checked against the media
+    // the flow traverses — the analysis the flow comment below describes and
+    // the model could not perform.
+    //
+    // Both are `allocation def`s rooted on the standard's
+    // `Allocations::Allocation`, because a binding IS an allocation and the
+    // language says so. The double specialization keeps MEMO's identification
+    // core from `MemoRelationship` while adding the standard's allocation
+    // semantics; both root on `Connections::BinaryConnection`, so this is a
+    // diamond and not a conflict. Verified under `syside check` against a
+    // negative control (a non-existent supertype is reported), so the clean
+    // result is the checker agreeing rather than the checker skipping.
+
+    // AADL `actual_memory_binding`. Which memory a software component's code
+    // and data occupy — what makes a memory budget a claim about a device
+    // rather than a string.
+    allocation def MemoryBinding :> MemoRelationship, Allocations::Allocation {
+        attribute bindingKind : String;
+        end boundComponent : SoftwareComponent :>> source;
+        end memory : MemoryDevice :>> target;
+    }
+    abstract connection memoryBindingLinks : MemoryBinding[*];
+    metadata def <memoryBinding> MemoryBindingMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::AllocationDefinition;
+        :> annotatedElement : SysML::AllocationUsage;
+        :>> baseType = memoryBindingLinks meta SysML::Usage;
+    }
+
+    // AADL `actual_connection_binding`. Which physical medium carries a
+    // component exchange. The source is the ComponentExchange rather than the
+    // `ComponentConnects` link, because the exchange is the ELEMENT that owns
+    // the budget (§19.3) and a link instance is not something the graph can
+    // bind to; it is also exactly where the latency the medium contributes has
+    // to be accounted.
+    allocation def ConnectionBinding :> MemoRelationship, Allocations::Allocation {
+        attribute allocatedBandwidth : String;
+        attribute mediumLatencyMs : Real;
+        end boundExchange : ComponentExchange :>> source;
+        end medium : NetworkMedium :>> target;
+    }
+    abstract connection connectionBindingLinks : ConnectionBinding[*];
+    metadata def <connectionBinding> ConnectionBindingMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::AllocationDefinition;
+        :> annotatedElement : SysML::AllocationUsage;
+        :>> baseType = connectionBindingLinks meta SysML::Usage;
     }
 
     // ─── AADL-style flow modeling (SAE AS5506) ───────────────────────────
@@ -68,8 +151,8 @@ package memo_architecture_realization_deployment {
     part def EndToEndFlow specializes ArchitectureElement {
         attribute latencyBudgetMs : Real;
         attribute analysisPurpose : String;
-        ref sourceFunction : SystemFunction[0..1];
-        ref sinkFunction : SystemFunction[0..1];
+        ref sourceFunction : MemoFunction[0..1];
+        ref sinkFunction : MemoFunction[0..1];
         ref logicalSegments : LogicalComponent[0..*];
         // Runtime C&C components (SEI) — the elements actually bound to hardware.
         ref softwareSegments : SoftwareComponent[0..*];
@@ -79,12 +162,24 @@ package memo_architecture_realization_deployment {
     // segment per traversed component boundary (AADL flow-spec → end-to-end).
     connection def FlowComprisesSpec :> MemoRelationship {
         attribute segmentOrder : Integer;
-        end endToEndFlow : EndToEndFlow;
-        end spec : FlowSpecification;
+        end endToEndFlow : EndToEndFlow :>> source;
+        end spec : FlowSpecification :>> target;
+    }
+    abstract connection flowComprisesSpecLinks : FlowComprisesSpec[*];
+    metadata def <flowComprisesSpec> FlowComprisesSpecMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = flowComprisesSpecLinks meta SysML::Usage;
     }
     // The flow traverses a software→hardware binding; latency accrues here.
     connection def FlowTraversesBinding :> MemoRelationship {
-        end endToEndFlow : EndToEndFlow;
-        end deploymentUnit : DeploymentUnit;
+        end endToEndFlow : EndToEndFlow :>> source;
+        end deploymentUnit : DeploymentUnit :>> target;
+    }
+    abstract connection flowTraversesBindingLinks : FlowTraversesBinding[*];
+    metadata def <flowTraversesBinding> FlowTraversesBindingMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = flowTraversesBindingLinks meta SysML::Usage;
     }
 }

package/src/architecture/realization/physical/memo_physical_architecture.sysml

@@ -22,9 +22,34 @@ package memo_architecture_realization_physical {
         attribute capacityMB : String;
         attribute nonVolatile : Boolean;
     }
-    part def PhysicalPort specializes InterfaceElement {
+    // A physical boundary feature: the connector the outside world plugs into.
+    //
+    // A `port def` (Track A1), not a part. It was `part def PhysicalPort
+    // specializes InterfaceElement` for one reason — the exchange endpoints
+    // were `MemoPart`-typed, so anything that terminated an exchange had to be
+    // a part (CR-ONT-002, since rewritten). Track A0 made those ends
+    // metaclass-neutral, and KerML forbids a port from specializing a
+    // part-based type, so the specialization moves to `MemoPort`.
+    //
+    // `direction` is gone: the port usage carries `in` / `out` / `inout`
+    // natively (Track A2). `DirectionKind` survives for the non-port
+    // constructs that still need it — see memo_core_enumerations.
+    //
+    // `portKind` is declared here AND on SoftwarePort rather than on a shared
+    // base. `MemoPort` is the identification core and nothing else — the block
+    // comment in memo_core_common makes that a stated invariant across all
+    // five bases — and pushing `portKind` down onto DataPort, SensorPort,
+    // CommandPort, and LogicalPort would give them a second classifier beside
+    // the ones they already carry (`interfaceType`, `sensorDomain`,
+    // `commandDomain`, `contentKind`). An intermediate `abstract port def`
+    // holding one attribute is a class standing in for an attribute, which is
+    // what the lean direction removes. One attribute, two sites, no new type.
+    port def PhysicalPort specializes MemoPort {
         attribute portKind : InterfaceKind;
+        // AADL port category (plan C2) — see SoftwarePort. A physical port
+        // carries it for the same reason: a sampled sensor line and a queued
+        // interrupt line fail differently under overload.
+        attribute portCategory : PortCategoryKind;
         attribute connectorType : String;
-        attribute direction : DirectionKind;
     }
 }

package/src/artifacts/configuration_management/memo_configuration_management.sysml

@@ -0,0 +1,35 @@
+package memo_artifacts_configuration_management {
+    private import Metaobjects::SemanticMetadata;
+    private import ScalarValues::*;
+    private import memo_core_relationships::*;   // MemoRelationship
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    part def ChangeRequest :> MemoPart {
+        attribute changeType : ChangeTypeKind;
+        attribute impactAssessment : String;
+        attribute approvalStatus : String;
+        attribute affectedBaseline : String;
+    }
+
+    part def ConfigurationItem :> MemoPart {
+        attribute version : String;
+        attribute baseline : String;
+        attribute controlLevel : String;
+    }
+
+    // ── Relations owned by this package ─────────────────────────────
+    // Moved out of memo_core_relationships: their ends are typed against
+    // types declared here, and core must not depend on a domain package.
+    connection def Changes :> MemoRelationship {
+        end changeRequest : ChangeRequest :>> source;
+        end changedElement : MemoPart :>> target;
+    }
+    abstract connection changesLinks : Changes[*];
+    metadata def <changes> ChangesMetadata :> SemanticMetadata {
+        :> annotatedElement : SysML::ConnectionDefinition;
+        :> annotatedElement : SysML::ConnectionUsage;
+        :>> baseType = changesLinks meta SysML::Usage;
+    }
+}

package/src/artifacts/core/memo_controlled_artifacts.sysml

@@ -0,0 +1,35 @@
+package memo_artifacts_core {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    abstract item def MemoArtifactItem :> MemoItem;
+
+    item def ControlledArtifact :> MemoArtifactItem {
+        attribute version : String;
+        attribute artifactKind : ArtifactKind;
+        attribute owner : String;
+        attribute approvalStatus : String;
+    }
+
+    part def ModelOwnedArtifact :> ControlledArtifact {
+        attribute uri : String;
+        attribute mediaType : String;
+        attribute contentHash : String;
+        attribute artifactVersion : String[0..1];
+        attribute authoredLanguage : String[0..1];
+        attribute executionEnvironment : String[0..1];
+        attribute generated : Boolean;
+    }
+
+    part def ADRArtifact :> ModelOwnedArtifact {
+        attribute decisionId : String;
+    }
+
+    part def MarkdownDocumentSource :> ModelOwnedArtifact {}
+    part def ModelQueryScript :> ModelOwnedArtifact {}
+    part def AnalysisNotebook :> ModelOwnedArtifact {}
+    part def ModelDataset :> ModelOwnedArtifact {}
+    part def GeneratedReport :> ModelOwnedArtifact {}
+}

package/src/artifacts/documents/risk_management/memo_risk_management.sysml

@@ -0,0 +1,12 @@
+package memo_artifacts_documents_risk_management {
+    private import ScalarValues::*;
+
+    private import memo_artifacts_core::*;
+
+    part def RiskManagementFile :> ModelOwnedArtifact {
+        attribute standardReference : String;
+        attribute clause : String;
+        attribute edition : String;
+        attribute completenessStatus : String;
+    }
+}

package/src/artifacts/standards/cfr_21_820.sysml

@@ -0,0 +1,116 @@
+// 21 CFR Part 820 — FDA Quality System Regulation, design controls.
+//
+// Only §820.30 (design controls) and its paragraphs are represented: those are
+// the provisions a design history file traces to. The production, purchasing
+// and records subparts are QMS scope that no model element claims.
+//
+// Terminology: under QMSR (effective February 2026) Part 820 incorporates
+// ISO 13485:2016 by reference, so a project may end up claiming both this pack
+// and the 13485 one for the same document. That is two claims about one
+// artifact, which is exactly what ConformsTo is for — it is not a duplicate
+// registry.
+package memo_artifacts_standards_cfr_21_820 {
+    private import ScalarValues::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_artifacts_standards_traceability::*;
+
+    item cfr21Part820 : RegulatoryStandard {
+        attribute :>> id = "STD-21-CFR-820";
+        attribute :>> name = "CFR21Part820";
+        attribute :>> designation = "21 CFR Part 820";
+        attribute :>> issuer = "FDA";
+        attribute :>> appliesToRegime = (RegulatoryRegimeKind::FDA_510k, RegulatoryRegimeKind::FDA_PMA);
+    }
+
+    item cfr820_30 : StandardClause {
+        attribute :>> id = "STD-21-CFR-820-30";
+        attribute :>> name = "CFR820_30";
+        attribute :>> clauseNumber = "820.30";
+        attribute :>> title = "design controls";
+        attribute :>> normativeStrength = "shall";
+    }
+    item cfr820_30a : StandardClause {
+        attribute :>> id = "STD-21-CFR-820-30-A";
+        attribute :>> name = "CFR820_30a";
+        attribute :>> clauseNumber = "820.30(a)";
+        attribute :>> title = "general design control applicability";
+        attribute :>> normativeStrength = "shall";
+    }
+    item cfr820_30b : StandardClause {
+        attribute :>> id = "STD-21-CFR-820-30-B";
+        attribute :>> name = "CFR820_30b";
+        attribute :>> clauseNumber = "820.30(b)";
+        attribute :>> title = "design and development planning";
+        attribute :>> normativeStrength = "shall";
+    }
+    item cfr820_30c : StandardClause {
+        attribute :>> id = "STD-21-CFR-820-30-C";
+        attribute :>> name = "CFR820_30c";
+        attribute :>> clauseNumber = "820.30(c)";
+        attribute :>> title = "design input";
+        attribute :>> normativeStrength = "shall";
+    }
+    item cfr820_30d : StandardClause {
+        attribute :>> id = "STD-21-CFR-820-30-D";
+        attribute :>> name = "CFR820_30d";
+        attribute :>> clauseNumber = "820.30(d)";
+        attribute :>> title = "design output";
+        attribute :>> normativeStrength = "shall";
+    }
+    item cfr820_30e : StandardClause {
+        attribute :>> id = "STD-21-CFR-820-30-E";
+        attribute :>> name = "CFR820_30e";
+        attribute :>> clauseNumber = "820.30(e)";
+        attribute :>> title = "design review";
+        attribute :>> normativeStrength = "shall";
+    }
+    item cfr820_30f : StandardClause {
+        attribute :>> id = "STD-21-CFR-820-30-F";
+        attribute :>> name = "CFR820_30f";
+        attribute :>> clauseNumber = "820.30(f)";
+        attribute :>> title = "design verification";
+        attribute :>> normativeStrength = "shall";
+    }
+    item cfr820_30g : StandardClause {
+        attribute :>> id = "STD-21-CFR-820-30-G";
+        attribute :>> name = "CFR820_30g";
+        attribute :>> clauseNumber = "820.30(g)";
+        attribute :>> title = "design validation";
+        attribute :>> normativeStrength = "shall";
+    }
+    item cfr820_30h : StandardClause {
+        attribute :>> id = "STD-21-CFR-820-30-H";
+        attribute :>> name = "CFR820_30h";
+        attribute :>> clauseNumber = "820.30(h)";
+        attribute :>> title = "design transfer";
+        attribute :>> normativeStrength = "shall";
+    }
+    item cfr820_30i : StandardClause {
+        attribute :>> id = "STD-21-CFR-820-30-I";
+        attribute :>> name = "CFR820_30i";
+        attribute :>> clauseNumber = "820.30(i)";
+        attribute :>> title = "design changes";
+        attribute :>> normativeStrength = "shall";
+    }
+    item cfr820_30j : StandardClause {
+        attribute :>> id = "STD-21-CFR-820-30-J";
+        attribute :>> name = "CFR820_30j";
+        attribute :>> clauseNumber = "820.30(j)";
+        attribute :>> title = "design history file";
+        attribute :>> normativeStrength = "shall";
+    }
+
+    connection cfr820Has30 : Composes connect parent ::> cfr21Part820 to child ::> cfr820_30;
+
+    connection cfr820_30HasA : Composes connect parent ::> cfr820_30 to child ::> cfr820_30a;
+    connection cfr820_30HasB : Composes connect parent ::> cfr820_30 to child ::> cfr820_30b;
+    connection cfr820_30HasC : Composes connect parent ::> cfr820_30 to child ::> cfr820_30c;
+    connection cfr820_30HasD : Composes connect parent ::> cfr820_30 to child ::> cfr820_30d;
+    connection cfr820_30HasE : Composes connect parent ::> cfr820_30 to child ::> cfr820_30e;
+    connection cfr820_30HasF : Composes connect parent ::> cfr820_30 to child ::> cfr820_30f;
+    connection cfr820_30HasG : Composes connect parent ::> cfr820_30 to child ::> cfr820_30g;
+    connection cfr820_30HasH : Composes connect parent ::> cfr820_30 to child ::> cfr820_30h;
+    connection cfr820_30HasI : Composes connect parent ::> cfr820_30 to child ::> cfr820_30i;
+    connection cfr820_30HasJ : Composes connect parent ::> cfr820_30 to child ::> cfr820_30j;
+}

package/src/artifacts/standards/fda_cybersecurity_2023.sysml

@@ -0,0 +1,80 @@
+// FDA guidance — "Cybersecurity in Medical Devices: Quality System
+// Considerations and Content of Premarket Submissions" (September 2023).
+//
+// Guidance, not a consensus standard, so every clause here carries
+// normativeStrength = "informative": FDA guidance describes current thinking
+// and is not binding. It is modelled as a RegulatoryStandard all the same,
+// because a submission traces to it exactly the way it traces to IEC 62304 —
+// the traceability question is identical, only the enforceability differs, and
+// that difference is data on the clause rather than a second mechanism.
+//
+// Reference granularity is the guidance's own lettered section structure
+// (IV, V.A, …), not a decimal clause numbering — this document has none. The
+// templates previously cited decimal numbers ("3.2", "5.2") that match no
+// section of the published guidance; those were replaced when this pack landed.
+package memo_artifacts_standards_fda_cybersecurity_2023 {
+    private import ScalarValues::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_artifacts_standards_traceability::*;
+
+    item fdaCybersecurity2023 : RegulatoryStandard {
+        attribute :>> id = "STD-FDA-CYBER-2023";
+        attribute :>> name = "FDACybersecurity2023";
+        attribute :>> designation = "FDA Cybersecurity Guidance 2023";
+        attribute :>> edition = "2023-09";
+        attribute :>> issuer = "FDA";
+        attribute :>> appliesToRegime = (RegulatoryRegimeKind::FDA_510k, RegulatoryRegimeKind::FDA_PMA);
+    }
+
+    item fdaCyberSection4 : StandardClause {
+        attribute :>> id = "STD-FDA-CYBER-2023-IV";
+        attribute :>> name = "FDACyberSectionIV";
+        attribute :>> clauseNumber = "IV";
+        attribute :>> title = "general cybersecurity principles";
+        attribute :>> normativeStrength = "informative";
+    }
+    item fdaCyberSection5 : StandardClause {
+        attribute :>> id = "STD-FDA-CYBER-2023-V";
+        attribute :>> name = "FDACyberSectionV";
+        attribute :>> clauseNumber = "V";
+        attribute :>> title = "secure product development framework";
+        attribute :>> normativeStrength = "informative";
+    }
+    item fdaCyberSection5A : StandardClause {
+        attribute :>> id = "STD-FDA-CYBER-2023-V-A";
+        attribute :>> name = "FDACyberSectionVA";
+        attribute :>> clauseNumber = "V.A";
+        attribute :>> title = "security risk management";
+        attribute :>> normativeStrength = "informative";
+    }
+    item fdaCyberSection5B : StandardClause {
+        attribute :>> id = "STD-FDA-CYBER-2023-V-B";
+        attribute :>> name = "FDACyberSectionVB";
+        attribute :>> clauseNumber = "V.B";
+        attribute :>> title = "security architecture";
+        attribute :>> normativeStrength = "informative";
+    }
+    item fdaCyberSection5C : StandardClause {
+        attribute :>> id = "STD-FDA-CYBER-2023-V-C";
+        attribute :>> name = "FDACyberSectionVC";
+        attribute :>> clauseNumber = "V.C";
+        attribute :>> title = "cybersecurity testing";
+        attribute :>> normativeStrength = "informative";
+    }
+    item fdaCyberSection6 : StandardClause {
+        attribute :>> id = "STD-FDA-CYBER-2023-VI";
+        attribute :>> name = "FDACyberSectionVI";
+        attribute :>> clauseNumber = "VI";
+        attribute :>> title = "cybersecurity transparency and vulnerability management";
+        attribute :>> normativeStrength = "informative";
+    }
+
+    connection fdaCyberHas4 : Composes connect parent ::> fdaCybersecurity2023 to child ::> fdaCyberSection4;
+    connection fdaCyberHas5 : Composes connect parent ::> fdaCybersecurity2023 to child ::> fdaCyberSection5;
+    connection fdaCyberHas6 : Composes connect parent ::> fdaCybersecurity2023 to child ::> fdaCyberSection6;
+
+    connection fdaCyberHas5A : Composes connect parent ::> fdaCyberSection5 to child ::> fdaCyberSection5A;
+    connection fdaCyberHas5B : Composes connect parent ::> fdaCyberSection5 to child ::> fdaCyberSection5B;
+    connection fdaCyberHas5C : Composes connect parent ::> fdaCyberSection5 to child ::> fdaCyberSection5C;
+}