@memoarchitect/ontology 0.4.6 → 0.6.0

package/src/architecture/logical/interfaces/memo_interfaces.sysml

@@ -0,0 +1,102 @@
+package memo_architecture_logical_interfaces {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_architecture_functional_functions::*;
+
+    // ─── One Interface definition ────────────────────────────────────
+    // Realization domain (hardware vs software), signaling family
+    // (digital / analog / synchronous / asynchronous) and concrete protocol
+    // (SPI, CAN, Ethernet, 4-20mA, REST, gRPC, message-queue …) are captured
+    // by `interfaceKind` + `protocol`, NOT by a class branch. Every
+    // descriptive attribute below is optional, so an interface carries only
+    // the ones that apply to it. There is no HardwareInterface /
+    // DigitalInterface / SPIInterface / RestInterface … hierarchy: those were
+    // 20+ classes that differed only in the value of `protocol`.
+
+    interface def Interface specializes MemoInterface {
+        attribute interfaceKind : InterfaceKind;   // semantic + signaling family
+        attribute direction : DirectionKind;
+        attribute protocol : String;               // "SPI", "CAN", "Ethernet", "REST", "4-20mA"
+        attribute protocolSemantics : String;
+        attribute interactionPattern : String;     // request-response, pub-sub, streaming…
+        attribute signalKind : String;
+        attribute timingSummary : String;
+        attribute timingConstraint : String;
+        attribute bandwidth : String;
+        attribute schemaReference : String;
+        attribute compatibilitySummary : String;
+        attribute isolationRequirement : String;
+        attribute safetyRelevant : Boolean;
+        attribute securityCriticality : CriticalityKind;
+        // Applied-part/patient-contact interfaces (IEC 60601-1) must state it.
+        attribute patientContactInterface : Boolean;
+        // ── hardware-signal descriptors (optional) ──
+        attribute directionality : DirectionKind[0..1];
+        attribute electricalStandard : String;
+        attribute nominalVoltageV : Real[0..1];
+        attribute nominalCurrentA : Real[0..1];
+        attribute bitRateBps : String;
+        attribute signaling : String;
+        attribute signalRange : String;
+        // ── software-API descriptors (optional) ──
+        attribute apiStyle : String;
+    }
+
+    // A typed thing exchanged at a boundary. Concrete items such as
+    // AlarmSignal and FlowCommand specialize this type; they are neither
+    // functions nor generic action-flow notation.
+    // The kind of item is given by itemKind (data / command / signal / …);
+    // the control-specific fields below apply only when itemKind = command.
+    item def InterfaceItem specializes MemoExchangeItem {
+        attribute itemKind : InterfaceItemKind;
+        attribute confidentialityClass : String;
+        attribute integrityClass : String;
+        attribute availabilityClass : String;
+        attribute controlType : String[0..1];
+        attribute timeoutMs : Real[0..1];
+        attribute retryPolicy : String[0..1];
+    }
+
+    // ─── Ports, interface defs, and exchanges ────────────────────────
+    // SysML port/interface mechanism + logical exchange, relocated here
+    // from the former logical_interfaces namespace.
+
+    abstract interface def DataInterface specializes MemoInterface {
+        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;
+        // Typed endpoints (CR-ONT-002). A component or a boundary port may
+        // terminate an exchange, so the ends are MemoPart-typed.
+        ref sourceEndpoint : MemoPart[0..1];
+        ref targetEndpoint : MemoPart[0..1];
+        // Descriptive port paths (e.g. "TLM.TLM_MODE_OUT") for AADL
+        // round-trips; labels only — never references.
+        attribute sourcePortPath : String;
+        attribute targetPortPath : String;
+        ref allocatedExchanges : FunctionalExchange[0..*];
+        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,150 @@
+// Logical architecture (§10). Technology-independent structure: what parts of
+// the solution exist and how they interact, before committing to software,
+// electronics, or mechanics. Redundancy is expressed by typed channel roles
+// plus independence constraints — never by duplicating identically named
+// components.
+package memo_architecture_logical_structure {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+
+    // What a logical connection carries: information and control, but also
+    // energy, material, fluid, and mechanical force (§10).
+    enum def FlowContentKind {
+        enum information;
+        enum command;
+        enum status;
+        enum measurement;
+        enum alarm;
+        enum configuration;
+        enum energy;
+        enum material;
+        enum fluid;
+        enum mechanicalForce;
+    }
+
+    enum def ChannelRoleKind {
+        enum primary;
+        enum secondary;
+        enum redundant;
+        enum diverse;
+        enum monitor;
+        enum watchdog;
+        enum interlock;
+        enum independentProtection;
+    }
+
+    // The role a logical component plays. Was a subclass branch
+    // (LogicalSystem / LogicalSubsystem / LogicalChannel / LogicalDataStore /
+    // LogicalControlElement / LogicalUserInterface / LogicalExternalSystem);
+    // now one attribute, because all of them share the same relationships and
+    // differed only by a couple of descriptive attributes.
+    enum def ComponentRoleKind {
+        enum system;
+        enum subsystem;
+        enum channel;
+        enum dataStore;
+        enum controlElement;
+        enum userInterface;
+        enum externalSystem;
+        enum generic;
+    }
+
+    // One logical component. `componentRole` selects what it is; the role-
+    // specific attributes below are all optional so a component carries only
+    // the ones its role needs. A channel claiming independence must still be
+    // linked by IndependentOf with its basis stated.
+    part def LogicalComponent specializes ArchitectureElement {
+        attribute componentRole : ComponentRoleKind;
+        attribute responsibility : String;
+        attribute decompositionLevel : String;
+        attribute safetyPartition : String;
+        // system / subsystem
+        attribute systemBoundaryDescription : String;
+        // channel (safety role + diversity)
+        attribute channelRole : ChannelRoleKind[0..1];
+        attribute diversityBasis : String;
+        // data store
+        attribute persistenceRequirement : String;
+        attribute integrityRequirement : String;
+        // control element
+        attribute controlLaw : String;
+        attribute controlledVariable : String;
+        // user interface
+        attribute interactionSummary : String;
+        // external system
+        attribute externalOwner : String;
+    }
+
+    // Boundary features and contracts.
+    port def LogicalPort specializes MemoPort {
+        attribute contentKind : FlowContentKind;
+    }
+    interface def LogicalInterface specializes MemoInterface {
+        attribute contentKind : FlowContentKind;
+        attribute interactionPattern : String;
+        end providerPort : LogicalPort;
+        end consumerPort : ~LogicalPort;
+    }
+    item def LogicalExchangeItem specializes MemoExchangeItem {
+        attribute contentKind : FlowContentKind;
+    }
+
+    // A typed logical connection between two components' ports.
+    connection def LogicalConnector :> MemoRelationship {
+        attribute contentKind : FlowContentKind;
+        attribute direction : DirectionKind;
+        end sourceComponent : LogicalComponent;
+        end targetComponent : LogicalComponent;
+    }
+    // A transfer of a typed item across a connector.
+    part def LogicalExchange specializes ArchitectureElement {
+        attribute contentKind : FlowContentKind;
+        attribute direction : DirectionKind;
+        attribute latencyRequirement : String;
+        ref exchangedItem : LogicalExchangeItem[0..1];
+        ref sourcePort : LogicalPort[0..1];
+        ref targetPort : LogicalPort[0..1];
+    }
+
+    // States and modes of the logical solution (kept distinct from UI state
+    // and from physical device configuration).
+    part def LogicalState specializes ArchitectureElement {
+        attribute stateInvariant : String;
+    }
+    part def LogicalMode specializes ArchitectureElement {
+        attribute modePurpose : String;
+        attribute entryCondition : String;
+        attribute exitCondition : String;
+    }
+    part def LogicalBehavior specializes ArchitectureElement {
+        attribute behaviorSummary : String;
+        attribute executionSemantics : String;
+    }
+
+    // Isolation, fault containment, and trust boundaries (§10).
+    part def IsolationBoundary specializes ArchitectureElement {
+        attribute boundaryKind : String;
+        attribute isolationMechanism : String;
+    }
+    part def FaultContainmentRegion specializes ArchitectureElement {
+        attribute containmentRationale : String;
+    }
+
+    // Claimed independence between channels (common-cause defense).
+    connection def IndependentOf :> MemoRelationship {
+        attribute independenceBasis : String;
+        end channel : LogicalComponent;
+        end otherChannel : LogicalComponent;
+    }
+    connection def MonitorsChannel :> MemoRelationship {
+        end monitorChannel : LogicalComponent;
+        end monitoredComponent : LogicalComponent;
+    }
+    connection def ExhibitsMode :> MemoRelationship {
+        end component : LogicalComponent;
+        end mode : LogicalMode;
+    }
+}

package/src/architecture/operational/activities/memo_activities.sysml

@@ -0,0 +1,86 @@
+// Operational activities and user tasks (§7, §17). Activities are behavioral
+// concepts (action defs on MemoAction). An OperationalActivity is work
+// performed in the operational world; a UserTask is a unit of user work within
+// an activity (IEC 62366-1); a critical task is a UserTask whose criticality is
+// high/catastrophic — its failure could cause serious harm (FDA HF guidance) and
+// it must trace to usability validation.
+// Task difficulty belongs to a task performed in a context — never to an
+// instrument (TaskDifficultyAssessment).
+package memo_architecture_operational_activities {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_context_actors::*;
+    private import memo_architecture_operational_context_use_context::*;
+
+    enum def DemandLevelKind {
+        enum minimal;
+        enum low;
+        enum moderate;
+        enum high;
+        enum extreme;
+    }
+
+    action def OperationalActivity specializes MemoAction {
+        attribute trigger : String;
+        attribute preCondition : String;
+        attribute postCondition : String;
+        attribute criticality : CriticalityKind;
+        ref performedBy : Actor[0..*];
+    }
+
+    // A human task. A critical task (IEC 62366-1 / FDA HF guidance §3) is a
+    // UserTask whose criticality is high or catastrophic — a use error could
+    // cause serious harm. potentialHarm/severityIfFailed are set only for such
+    // tasks. Modeled as an attribute, like SystemFunction.criticality.
+    action def UserTask specializes MemoAction {
+        attribute taskGoal : String;
+        attribute preCondition : String;
+        attribute postCondition : String;
+        attribute expectedDuration : String;
+        attribute frequencyOfUse : String;
+        attribute criticality : CriticalityKind;
+        attribute potentialHarm : String[0..1];
+        attribute severityIfFailed : SeverityKind[0..1];
+        ref performingUser : User[0..1];
+    }
+
+    // An elementary perceptual/cognitive/motor step within a user task
+    // (task analysis granularity: grasp needle, drive needle, tie knot …).
+    action def TaskStep specializes MemoAction {
+        attribute stepOrder : Integer;
+        attribute perceptualCue : String;
+        attribute feedbackExpected : String;
+    }
+
+    // Difficulty of a task in a particular context (§17). Associated by
+    // typed references, not inheritance; assessments are evidence-bearing.
+    part def TaskDifficultyAssessment specializes MemoPart {
+        attribute overallDifficulty : DemandLevelKind;
+        attribute physicalDemand : DemandLevelKind;
+        attribute cognitiveDemand : DemandLevelKind;
+        attribute perceptualDemand : DemandLevelKind;
+        attribute dexterityDemand : DemandLevelKind;
+        attribute coordinationDemand : DemandLevelKind;
+        attribute timePressure : DemandLevelKind;
+        attribute trainingDemand : DemandLevelKind;
+        attribute ergonomicDemand : DemandLevelKind;
+        attribute environmentalDemand : DemandLevelKind;
+        attribute expectedDuration : String;
+        attribute assessor : String;
+        attribute assessmentMethod : String;
+
+        ref assessedTask : UserTask[0..1];
+        ref userPopulation : User[0..1];
+        ref useEnvironment : UseEnvironment[0..1];
+        ref instrument : MemoPart[0..1];
+        ref scenario : MemoPart[0..1];
+    }
+
+    connection def AssessesDifficulty :> MemoRelationship {
+        end assessment : TaskDifficultyAssessment;
+        end task : UserTask;
+    }
+}

package/src/architecture/operational/context/actors/memo_actors.sysml

@@ -0,0 +1,38 @@
+// Actor hierarchy (§4). An Actor interacts with the system; it is distinct
+// from a Stakeholder (memo_architecture_operational_context_stakeholders), who has concerns about the
+// system but need not interact with it. "User" is reserved for a human who
+// interacts with the medical device.
+package memo_architecture_operational_context_actors {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+
+    abstract part def Actor specializes MemoPart {
+        attribute actorKind : ActorKind;
+        attribute trainingLevel : String;
+        attribute responsibility : String;
+    }
+
+    // A human who interacts with the medical device (IEC 62366-1 intended user).
+    // User is the only human actor type: do not add an alternative type name.
+    // The human actor. The specific role is given by actorKind
+    // (patient / clinician / caregiver / technician / administrator); the
+    // role-specific fields below are set only for the relevant actorKind.
+    part def User specializes Actor {
+        attribute userPopulation : String;
+        attribute impairmentConsiderations : String;
+        attribute intendedTraining : String;
+        attribute intendedQualification : String;
+        attribute clinicalRole : String[0..1];
+        attribute patientPopulation : String[0..1];
+        attribute layCaregiver : Boolean[0..1];
+        attribute serviceScope : String[0..1];
+    }
+
+    // A non-human actor (external system, external device, or environmental
+    // agent). The specific kind is described by externalKind.
+    part def NonHumanActor specializes Actor {
+        attribute externalKind : String[0..1];
+    }
+}

package/src/architecture/operational/context/stakeholders/memo_stakeholders.sysml

@@ -0,0 +1,64 @@
+// ISO/IEC/IEEE 42010 architecture-description core (§4). A Stakeholder has
+// interests (Concerns) in the system; a Viewpoint frames concerns; a View
+// (memo_viewpoints_definitions::MemoView) is governed by a viewpoint within an
+// ArchitectureDescription. The same real-world entity may play both the
+// Stakeholder and the Actor role — expressed by ActsAsActor, never by merging
+// the types.
+package memo_architecture_operational_context_stakeholders {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_context_actors::*;
+
+    part def Stakeholder specializes MemoPart {
+        attribute stakeholderCategory : String;
+        attribute influence : String;
+    }
+
+    part def Concern specializes MemoPart {
+        attribute concernKind : ConcernKind;
+        attribute question : String;
+    }
+
+    part def ArchitectureDescription specializes DocumentedElement {
+        attribute systemOfInterest : String;
+        attribute version : String;
+    }
+
+    part def ModelKind specializes MemoPart {
+        attribute conventions : String;
+        attribute notationReference : String;
+    }
+
+    // 42010 correspondence: a rule that must hold between architecture
+    // description elements (e.g. consistency between two views).
+    part def CorrespondenceRule specializes MemoPart {
+        attribute ruleExpression : String;
+    }
+
+    connection def HasConcern :> MemoRelationship {
+        end interestedStakeholder : Stakeholder;
+        end concern : Concern;
+    }
+    connection def FramesConcern :> MemoRelationship {
+        end framingViewpoint : MemoPart;
+        end framedConcern : Concern;
+    }
+    // Links the stakeholder to the actor role the same entity plays, if any.
+    connection def ActsAsActor :> MemoRelationship {
+        end interestedStakeholder : Stakeholder;
+        end actorRole : Actor;
+    }
+    // Governs unifies GovernsCorrespondence / GovernsUse, keyed by governKind.
+    enum def GovernKind {
+        enum correspondence;
+        enum use;
+    }
+    connection def Governs :> MemoRelationship {
+        attribute governKind : GovernKind;
+        end governor : MemoPart;
+        end governedElement : MemoPart;
+    }
+}

package/src/architecture/operational/context/use_context/memo_use_context.sysml

@@ -0,0 +1,53 @@
+// Operational use context (IEC 62366-1 use specification). Intended use and
+// reasonably foreseeable misuse are assurance requirements/risk inputs and
+// live in memo_assurance_requirements.
+package memo_architecture_operational_context_use_context {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_context_actors::*;
+
+    part def UseContext specializes MemoPart {
+        attribute careSetting : String;
+        attribute environment : String;
+        attribute jurisdiction : String;
+        attribute connectedUse : Boolean;
+        attribute intendedUseReference : String;
+    }
+
+    // The physical/organizational environment of use (IEC 62366-1 3.20),
+    // separable from the care-setting context so environments are reusable.
+    part def UseEnvironment specializes MemoPart {
+        attribute lighting : String;
+        attribute noise : String;
+        attribute vibration : String;
+        attribute temperatureRange : String;
+        attribute infectionControlConstraints : String;
+        attribute mobility : String;
+    }
+
+    connection def InteractsWith :> MemoRelationship {
+        end contextParticipant : Actor;
+        end target : MemoPart;
+    }
+    // Directional context-level data flow between boundary entities.
+    connection def ExchangesWith :> MemoRelationship {
+        end source : MemoPart;
+        end target : MemoPart;
+    }
+    // Physical connection between boundary entities (fluid path, mounting).
+    connection def ConnectsPhysically :> MemoRelationship {
+        end source : MemoPart;
+        end target : MemoPart;
+    }
+    connection def AppliesInContext :> MemoRelationship {
+        end useContext : UseContext;
+        end subjectElement : MemoPart;
+    }
+    connection def SituatedIn :> MemoRelationship {
+        end useContext : UseContext;
+        end environment : UseEnvironment;
+    }
+}

package/src/architecture/operational/scenarios/memo_scenarios.sysml

@@ -0,0 +1,116 @@
+// Scenario foundation. A scenario is a selected path through a
+// workflow (or functional flow), classified by three independent typed
+// dimensions — variant, operational condition, purpose — replacing the former
+// single ScenarioKind. An occurrence is an actual or hypothetical execution
+// of a scenario. Alternate scenarios reference their base scenario and
+// variation point instead of duplicating the workflow.
+package memo_architecture_operational_scenarios {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_context_actors::*;
+    private import memo_architecture_operational_context_use_context::*;
+    private import memo_architecture_operational_activities::*;
+    private import memo_architecture_operational_workflows::*;
+    private import memo_architecture_operational_use_cases::*;
+
+    enum def ScenarioVariantKind {
+        enum nominal;
+        enum alternate;
+        enum exception;
+        enum recovery;
+    }
+
+    enum def OperationalConditionKind {
+        enum normal;
+        enum degraded;
+        enum emergency;
+        enum maintenance;
+        enum startup;
+        enum shutdown;
+        enum timeout;
+        enum misuse;
+        enum foreseeableMisuse;
+    }
+
+    // `memoAnalysis` and `memoVerification` keep the regulated terms `analysis`
+    // and `verification` intact but prefixed, because both are SysML v2 reserved
+    // words and cannot be bare enum names. `validation` is not reserved.
+    enum def ScenarioPurposeKind {
+        enum memoAnalysis;
+        enum design;
+        enum memoVerification;
+        enum validation;
+        enum risk;
+        enum cybersecurity;
+    }
+
+    // Shared scenario foundation. Specializations exist only where structure
+    // or invariants differ (OperativeScenario here; FunctionalScenario in
+    // memo_functions; UIScenario in memo_architecture_implementation_ui;
+    // VerificationScenario / ThreatScenario in assurance packages).
+    abstract part def MemoScenario specializes MemoPart {
+        attribute variantKind : ScenarioVariantKind;
+        attribute operationalCondition : OperationalConditionKind;
+        attribute scenarioPurpose : ScenarioPurposeKind[0..*];
+        attribute initialState : String;
+        attribute trigger : String;
+        attribute preCondition : String;
+        attribute expectedResult : String;
+        attribute postCondition : String;
+        attribute pathSummary : String;
+
+        ref involvedActors : Actor[0..*];
+        ref useContext : UseContext[0..1];
+        // Alternate/exception/recovery scenarios reference their base and the
+        // point at which behavior diverges — never a copied workflow.
+        ref baseScenario : MemoScenario[0..1];
+        attribute variationPoint : String;
+    }
+
+    // The operational-layer scenario: a path through an OperationalWorkflow in
+    // a use context. It is realized down the V by a FunctionalScenario (the
+    // function sequence) and a UIScenario (the interaction sequence), each owned
+    // by its own architecture layer and linked by typed realization
+    // relationships — never by copying the path. Workflow stays operational;
+    // only the scenario is layered.
+    part def OperativeScenario specializes MemoScenario {
+        ref parentWorkflow : OperationalWorkflow[0..1];
+        ref parentUseCase : UseCase[0..1];
+        // Each scenario owns the operational activity/action flow for its
+        // selected path. Do not reuse one generic activity for every scenario.
+        ref activities : OperationalActivity[0..*];
+    }
+
+    // An actual or hypothetical execution of a scenario (usability test run,
+    // postmarket incident reconstruction, simulated-use session).
+    part def ScenarioOccurrence specializes MemoPart {
+        attribute occurredAt : String;
+        attribute hypothetical : Boolean;
+        attribute outcomeSummary : String;
+        ref executedScenario : MemoScenario[1];
+    }
+
+    // Ordered selection of a workflow step into a scenario path.
+    // Selects unifies SelectsStep / SelectsFlow (a scenario selects its path
+    // element), keyed by selectsKind.
+    enum def SelectsKind {
+        enum step;
+        enum flow;
+    }
+    connection def Selects :> MemoRelationship {
+        attribute selectsKind : SelectsKind;
+        attribute pathOrder : Integer[0..1];
+        attribute decisionTaken : String[0..1];
+        end scenario : MemoScenario;
+        // A selected path element may be a WorkflowStep action or a flow
+        // element. Those constructs do not share a MEMO base metaclass.
+        end selected;
+    }
+    connection def OccursDuring :> MemoRelationship {
+        end occurrence : ScenarioOccurrence;
+        end context : UseContext;
+    }
+}

package/src/architecture/operational/structure/memo_operational.sysml

@@ -0,0 +1,26 @@
+package memo_architecture_operational_structure {
+    private import ScalarValues::*;
+
+    private import memo_core_common::*;
+    private import memo_core_enumerations::*;
+    private import memo_core_relationships::*;
+    private import memo_architecture_operational_activities::*;
+    // OperationalActivity now lives in memo_architecture_operational_activities (action def) and
+    // Operational scenarios are defined in memo_architecture_operational_scenarios.
+    part def OperationalEntity specializes ArchitectureElement {
+        attribute entityKind : OperationalEntityKind;
+        attribute operationalDomain : String;
+        attribute responsibility : String;
+    }
+    part def OperationalCapability specializes ArchitectureElement {
+        attribute capabilityLevel : String;
+        attribute preCondition : String;
+        attribute postCondition : String;
+    }
+    part def OperationalInteraction specializes ArchitectureElement {
+        attribute exchangeKind : FlowKind;
+        attribute direction : DirectionKind;
+        attribute latencyConstraint : String;
+    }
+
+}