memo_artifacts_configuration_management

SysML API

Public namespace	memo::artifacts::configuration_management
Declared package	memo_artifacts_configuration_management
Source	src/artifacts/configuration_management/memo_configuration_management.sysml

Namespace hierarchy

memo → memo::artifacts → memo::artifacts::configuration_management

Packages

Package
memo_artifacts_configuration_management

Imports

Visibility	Target
private	Metaobjects::SemanticMetadata
private	ScalarValues::*
private	memo_core_relationships::*
private	memo_core_common::*
private	memo_core_enumerations::*

Declarations

Name	SysML kind	Description	Specializes
ChangeRequest	part def	Change request definition specializing MemoPart.	MemoPart
ConfigurationItem	part def	Configuration item definition specializing MemoPart.	MemoPart
ReleaseRecord	part def	Release record definition specializing MemoPart.	MemoPart
ReleaseOf	metadata def	#ReleaseOf dependency from <record> to <item definition>; The record is a release of this item. One record, one item.	MemoTypedDependency
Contains	metadata def	#Contains dependency from <record> to <record>, <record>; The release pins these releases: a system of systems version its systems, a system release its components.	MemoTypedDependency
Implements	metadata def	#Implements dependency from <record> to <interface record>; The release implements this revision of an interface.	MemoTypedDependency
VerifiedByCase	metadata def	#VerifiedByCase dependency from <record> to <verification case>; The case that verified, or for a system of systems version validated, this release. verifiedBy is taken by the native relation from a requirement to its case.	MemoTypedDependency
AffectsRelease	metadata def	#AffectsRelease dependency from <change request> to <record>; The release a change request is raised against.	MemoTypedDependency
RegulatedDevice	part def	Regulated device definition specializing MemoPart.	MemoPart
Covers	metadata def	#Covers dependency from <device>, to <record>, <record>; The approval covers these system releases.	MemoTypedDependency
IntendedUseOf	metadata def	#IntendedUseOf dependency from <intended use> to <device>; The intended use (a requirement) states what this device is for.	MemoTypedDependency
UsedWith	metadata def	#UsedWith dependency from <device> to <device>, <device>; The device is used with these regulated devices (compatible devices and approved accessories).	MemoTypedDependency
Project	part def	Project definition specializing MemoPart.	MemoPart
Feeds	metadata def	#Feeds dependency from <project> to <record>, <record>; The project's work is in these releases.	MemoTypedDependency
IntroducedBy	metadata def	#IntroducedBy dependency from <variant> to <project>; The project that introduced this variant.	MemoTypedDependency
Changes	connection def	Typed relationship from ChangeRequest to MemoPart.	MemoRelationship

ChangeRequest

part def ChangeRequest :> MemoPart

Property	Value
Description	Change request definition specializing MemoPart.
Kind	part def
Abstract	No
Specializes	MemoPart
Owning package	memo_artifacts_configuration_management

ConfigurationItem

part def ConfigurationItem :> MemoPart

Property	Value
Description	Configuration item definition specializing MemoPart.
Kind	part def
Abstract	No
Specializes	MemoPart
Owning package	memo_artifacts_configuration_management

ReleaseRecord

part def ReleaseRecord :> MemoPart

Property	Value
Description	Release record definition specializing MemoPart.
Kind	part def
Abstract	No
Specializes	MemoPart
Owning package	memo_artifacts_configuration_management

ReleaseOf

metadata def ReleaseOf :> MemoTypedDependency

Property	Value
Description	#ReleaseOf dependency from <record> to <item definition>; The record is a release of this item. One record, one item.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_artifacts_configuration_management

Contains

metadata def Contains :> MemoTypedDependency

Property	Value
Description	#Contains dependency from <record> to <record>, <record>; The release pins these releases: a system of systems version its systems, a system release its components.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_artifacts_configuration_management

Implements

metadata def Implements :> MemoTypedDependency

Property	Value
Description	#Implements dependency from <record> to <interface record>; The release implements this revision of an interface.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_artifacts_configuration_management

VerifiedByCase

metadata def VerifiedByCase :> MemoTypedDependency

Property	Value
Description	#VerifiedByCase dependency from <record> to <verification case>; The case that verified, or for a system of systems version validated, this release. verifiedBy is taken by the native relation from a requirement to its case.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_artifacts_configuration_management

AffectsRelease

metadata def AffectsRelease :> MemoTypedDependency

Property	Value
Description	#AffectsRelease dependency from <change request> to <record>; The release a change request is raised against.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_artifacts_configuration_management

RegulatedDevice

part def RegulatedDevice :> MemoPart

Property	Value
Description	Regulated device definition specializing MemoPart.
Kind	part def
Abstract	No
Specializes	MemoPart
Owning package	memo_artifacts_configuration_management

Covers

metadata def Covers :> MemoTypedDependency

Property	Value
Description	#Covers dependency from <device>, to <record>, <record>; The approval covers these system releases.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_artifacts_configuration_management

IntendedUseOf

metadata def IntendedUseOf :> MemoTypedDependency

Property	Value
Description	#IntendedUseOf dependency from <intended use> to <device>; The intended use (a requirement) states what this device is for.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_artifacts_configuration_management

UsedWith

metadata def UsedWith :> MemoTypedDependency

Property	Value
Description	#UsedWith dependency from <device> to <device>, <device>; The device is used with these regulated devices (compatible devices and approved accessories).
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_artifacts_configuration_management

Project

part def Project :> MemoPart

Property	Value
Description	Project definition specializing MemoPart.
Kind	part def
Abstract	No
Specializes	MemoPart
Owning package	memo_artifacts_configuration_management

Feeds

metadata def Feeds :> MemoTypedDependency

Property	Value
Description	#Feeds dependency from <project> to <record>, <record>; The project's work is in these releases.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_artifacts_configuration_management

IntroducedBy

metadata def IntroducedBy :> MemoTypedDependency

Property	Value
Description	#IntroducedBy dependency from <variant> to <project>; The project that introduced this variant.
Kind	metadata def
Abstract	No
Specializes	MemoTypedDependency
Owning package	memo_artifacts_configuration_management

Changes

connection def Changes :> MemoRelationship

Property	Value
Description	Typed relationship from ChangeRequest to MemoPart.
Kind	connection def
Abstract	No
Specializes	MemoRelationship
Owning package	memo_artifacts_configuration_management

Source

artifacts/configuration_management/memo_configuration_management.sysml

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;
        // The release a change affects is `#AffectsRelease dependency from <request> to <record>;`
        // (below), not a string naming a baseline.
    }

    part def ConfigurationItem :> MemoPart {
        // No version and no baseline: both belong to a release of the item, not to the item
        // (plan O2). A `ReleaseRecord` whose `#ReleaseOf` is this item carries them.
        attribute controlLevel : String;
    }

    // A release record is one release of one item: rev D and rev E of a part, or its EU and its US
    // release, are separate records, each with its own part number and revision (plan O2). The
    // definition of the item is held once and carries no revision. The record is an element with a
    // status (inherited from MemoPart: proposed, draft, ... released), so a release moves through
    // the lifecycle the way any element does.
    //
    //   part relPumpD : ReleaseRecord {
    //       :>> partNumber = "PN-1001"; :>> revision = "D"; :>> modelCommit = "9f2c...";
    //   }
    //   #ReleaseOf dependency from relPumpD to PumpSystem;
    //
    // `softwareVersion` and `codeTag` are for an item that is software; a record of anything else
    // leaves them out. The links are typed dependencies, because a record's item is a definition and
    // a `ref` cannot point at one: a Dependency's client and supplier are any element
    // (SysML-textual-bnf.kebnf:51-59), and the metadata prefix names the kind (`:52`).
    //
    // A release of a system of systems is the same record with a system of systems for its item. It
    // `#Contains` the records of the system releases it pins, and is the validated configuration:
    // `#VerifiedByCase` names the verification cases that validated it.
    part def ReleaseRecord :> MemoPart {
        attribute :>> partNumber : String[1];
        attribute :>> revision : String[1];
        attribute softwareVersion : String[0..1];
        attribute codeTag : String[0..1];
        // The commit of the model this release was built from. A record cannot hold the hash of the
        // commit that adds it, so it is written after the commit it pins and is always found in a
        // folder that is not itself pinned (`sos/`).
        attribute modelCommit : String[1];
    }

    metadata def ReleaseOf :> MemoTypedDependency {
        doc /* `#ReleaseOf dependency from <record> to <item definition>;` The record is a release of this item. One record, one item. */
    }
    metadata def Contains :> MemoTypedDependency {
        doc /* `#Contains dependency from <record> to <record>, <record>;` The release pins these releases: a system of systems version its systems, a system release its components. */
    }
    metadata def Implements :> MemoTypedDependency {
        doc /* `#Implements dependency from <record> to <interface record>;` The release implements this revision of an interface. */
    }
    metadata def VerifiedByCase :> MemoTypedDependency {
        doc /* `#VerifiedByCase dependency from <record> to <verification case>;` The case that verified, or for a system of systems version validated, this release. `verifiedBy` is taken by the native relation from a requirement to its case. */
    }
    metadata def AffectsRelease :> MemoTypedDependency {
        doc /* `#AffectsRelease dependency from <change request> to <record>;` The release a change request is raised against. */
    }

    // A regulated device is one approval in one jurisdiction (plan O6): the thing a regulator is asked to
    // clear. It is not an item and not a release: it COVERS the system releases the approval names, so two
    // markets can ship different releases of one system, each with its own design history and risk file.
    //
    //   part deviceFda : RegulatedDevice {
    //       attribute :>> jurisdiction = RegulatoryRegimeKind::FDA_510k;
    //       attribute :>> submissionId = "K123456";
    //   }
    //   #Covers dependency from deviceFda to relPumpD;
    //
    // The jurisdiction is a `RegulatoryRegimeKind`, the same enum the standards library and the document
    // templates (`required_for`) are written against, so a device selects the standards it must meet and the
    // documents it must have. It replaces `ModelMethodBinding.regulatoryRegime`, which stated one regime set
    // for a whole model and is read only when the model declares no device.
    //
    // The device's other two links (plan O6), both typed dependencies like `Covers`:
    //
    //   #IntendedUseOf dependency from pumpIntendedUse to deviceFda;
    //   #UsedWith dependency from deviceFda to deviceInfusionSet;
    //
    // `IntendedUseOf` runs from the intended use (a `requirement def`, `IntendedUse`) to the device, as its
    // name reads; a device can have one per indication. `UsedWith` runs between regulated devices: the
    // compatible devices and accessories that are themselves approved. An accessory that is not a device is
    // not a target (decided 2026-10-25, user).
    part def RegulatedDevice :> MemoPart {
        attribute jurisdiction : RegulatoryRegimeKind[1];
        attribute submissionId : String[0..1];
    }

    metadata def Covers :> MemoTypedDependency {
        doc /* `#Covers dependency from <device>, to <record>, <record>;` The approval covers these system releases. */
    }
    metadata def IntendedUseOf :> MemoTypedDependency {
        doc /* `#IntendedUseOf dependency from <intended use> to <device>;` The intended use (a requirement) states what this device is for. */
    }
    metadata def UsedWith :> MemoTypedDependency {
        doc /* `#UsedWith dependency from <device> to <device>, <device>;` The device is used with these regulated devices (compatible devices and approved accessories). */
    }

    // A project is a change set in an iteration (plan O7): the work that produces releases. It holds a link to
    // where the work is tracked and nothing else; the merge request is the approval. It FEEDS the release records
    // it contributes to, and a variant records the project that introduced it, so "which work gave us this
    // option, and which releases did it reach" is two links.
    //
    //   part prjIrrigatedTip : Project { attribute :>> trackerLink = "https://tracker.example/PRJ-12"; }
    //   #Feeds dependency from prjIrrigatedTip to relGeneratorEu, relGeneratorUs;
    //   #IntroducedBy dependency from outputStage::usOutput to prjIrrigatedTip;
    part def Project :> MemoPart {
        attribute trackerLink : String[0..1];
    }

    metadata def Feeds :> MemoTypedDependency {
        doc /* `#Feeds dependency from <project> to <record>, <record>;` The project's work is in these releases. */
    }
    metadata def IntroducedBy :> MemoTypedDependency {
        doc /* `#IntroducedBy dependency from <variant> to <project>;` The project that introduced this variant. */
    }

    // ── 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;
    }
}