memo_core_enumerations

SysML API

Public namespace	memo::core::enumerations
Declared package	memo_core_enumerations
Source	src/core/enumerations/memo_enumerations.sysml

Namespace hierarchy

memo → memo::core → memo::core::enumerations

Packages

Package
memo_core_enumerations

Imports

Visibility	Target
private	ScalarValues::*

Declarations

Name	SysML kind	Description	Specializes
LegendSourceKind	enum def	Where a legend gets the value it colours by, when that value is not stored on the element at all but derived from the model.	—
LegendScopeKind	enum def	What a legend colours. The values are SysML's own usage keywords, so a renderer matches an element's construct directly rather than translating a private vocabulary into one.	—
ConcernKind	enum def	Controlled values for concern: safety, usability, cybersecurity, performance, interoperability, reliability, privacy, regulatory, clinical.	—
RequirementSourceKind	enum def	Controlled values for requirement source: stakeholderNeed, risk, designDecision, changeRequest, sourceDocument, extension.	—
NotificationPriorityKind	enum def	Notification/alarm priority as used by source requirement documents (e.g. CriSys GPCA REQ 59 action table: High/Med/Low).	—
RequirementNotationKind	enum def	Controlled values for requirement notation: freeText, ears, sophist, formalConstraint.	—
EarsPatternKind	enum def	Controlled values for ears pattern: ubiquitous, eventDriven, stateDriven, optionalFeature, unwantedBehavior, complex.	—
ObligationKind	enum def	Controlled values for obligation: shall, should, will.	—
InterfaceKind	enum def	Controlled values for interface: data, control, analogSignal, digitalSignal, power, network, api, userInteraction, notification, logging, mechanical, fluidic.	—
SignalingKind	enum def	Continuous value: the quantity IS the information (a 0.5-4.5 V sensor output, a 4-20 mA loop). Needs a range, accuracy and noise bound.	—
PhysicalMediumKind	enum def	The physical medium a hardware connection runs over.	—
PortCategoryKind	enum def	Sampled. The reader sees the most recent value; a missed deadline drops a sample and never blocks.	—
FlowKind	enum def	Controlled values for flow: information, command, status, telemetry, alarm, configuration, measurement, audit, power.	—
DirectionKind	enum def	Direction of a flow across a boundary. Track A2 removed this from PORTS: a port usage says in / out / inout natively, which is the language's own spelling and the only one a conforming tool reads.…	—
CriticalityKind	enum def	Controlled values for criticality: low, medium, high, catastrophic.	—
SafetyClassKind	enum def	Controlled values for safety class: none, A, B, C.	—
ComplexityKind	enum def	Controlled values for complexity: low, medium, high, complex.	—
LifecycleStateKind	enum def	Controlled values for lifecycle state: concept, development, released, maintenance, obsolete.	—
MemoVerificationMethodKind	enum def	Controlled values for memo verification method: inspection, analytical, demonstration, test, simulation, formalProof, modelChecking.	—
RegulatoryRegimeKind	enum def	The submission regime a model targets, and the regimes a standard has standing in. This is the axis that decides which clauses a model is required to claim: required(model) is the clauses of every standard whose appliesToRegime intersects the regimes the model's ModelMetho…	—
ArtifactKind	enum def	Controlled values for artifact: plan, requirementSpecification, architectureDescription, softwareDesignDescription, riskRecord, traceMatrix, testProtocol, testReport, evidenceRecord, cybersecurityAssessment, threatModel, usabilityEngineeringReport, clinicalSafetyReport, failureModeEffectsAnalysis, soupList, designInputPlan, designOutputPlan, softwareDevelopmentPlan, labelingSpecification, designHistoryFileIndex, designChangeLog.	—
RiskControlKind	enum def	Controlled values for risk control: inherentSafeDesign, protectiveMeasure, informationForSafety, alarm, interlock, monitoring, plausibilityCheck.	—
HazardTypeKind	enum def	Controlled values for hazard type: drugDeliveryError, energyExposure, informationError, mechanicalFailure, biologicalContamination, softwareAnomaly, useError, environmentalHazard.	—
CauseSourceKind	enum def	Cause-source categories for hazard causal trees. Mirrors the cause-source tables of the FDA GIIP hazard taxonomy (Zhang et al. 2010, Tables 2-9) and the section headings of the GIP Hazard Analysis v1.0 (Arney et al. 2009, section 2.4.1-2.4.8).	—
PortDisplayKind	enum def	Controlled values for port display: everything, ports, hidden.	—
ConnectionDisplayKind	enum def	Controlled values for connection display: summary, everything, hidden.	—
DiagramViewKind	enum def	Controlled values for diagram view: general, interconnection, actionflow, statetransition, sequence, grid, browser, geometry.	—
DocumentViewKind	enum def	Controlled values for document view: DHF, SDD, RMF, VV, architectureDescription, cybersecurityAssessment, threatModel, clinical, usability.	—
SchedulingPolicyKind	enum def	Controlled values for scheduling policy: nonRealTime, roundRobin, fixedPriorityPreemptive, rateMonotonic, deadlineMonotonic, EDF.	—
BehaviorPropertyKind	enum def	Controlled values for behavior property: stateInvariant, transitionRule, temporalProperty, safetyProperty, livenessProperty, assumption, guarantee.	—
InterfaceItemKind	enum def	Controlled values for interface item: data, command, signal, material, energy, fluid, mechanicalForce.	—
PropertyLanguageKind	enum def	Controlled values for property language: naturalLanguage, pseudoFormal, agreeLike, ltlLike, ctlLike.	—
RuleStrengthKind	enum def	Controlled values for rule strength: optional, recommended, required, forbidden.	—
RulePredicateKind	enum def	Controlled values for rule predicate: requireRelationship, conditionalRequireRelationship, requireAttribute, uniqueAttribute, cardinalityCheck, coverageCheck.	—
RuleSeverityKind	enum def	Controlled values for rule severity: error, warning, info.	—
RuleCategoryKind	enum def	Controlled values for rule category: closure, coverage, lifecycle, crossLayer, quantitative.	—
RuleTailoringKind	enum def	How far a methodology may tailor a rule. invariant rules hold the ontology's own consistency and may only change in an ontology release; assurance and methodology rules may be disabled or replaced through an explicit RulePolicy carrying rationale and authority.	—
RuleDomainKind	enum def	Why a rule exists. modelling rules keep a model well formed whatever the product is. medicalDevice rules exist because a medical-device standard or guidance asks for the thing they check, and each should say which clause it enforces (`#EnforcesClause dependency from …	—
RuleObligationKind	enum def	How firmly the rule's source asks for what it checks, separate from the severity a finding carries and from how far the rule may be tailored.…	—
WorkspaceMembershipKind	enum def	How a relation places elements in a workspace; see memo_core_relationships_workspace_membership.	—
RuleDispositionKind	enum def	Controlled values for rule disposition: enabled, disabled, replaced.	—
ScopeModeKind	enum def	Whether a methodology's inclusion lists are the whole selection or a deliberate subset. An empty list under explicit selects nothing; it never means "everything". allAvailable is the only way to say "all", and it is always deliberate.…	—
WorkflowStageKind	enum def	Controlled values for workflow stage: context, requirements, behavior, architecture, interfaces, risk, verificationStage, evidence, documents, operational, functional, logical, physical, humanFactors, security, release.	—
MethodLevelKind	enum def	The level a method step is worked at: the system of systems, or one system.	—
ThreatCategoryKind	enum def	Controlled values for threat category: spoofing, tampering, repudiation, informationDisclosure, denialOfService, elevationOfPrivilege, privacyLoss, supplyChain.	—
CyberControlKind	enum def	Controlled values for cyber control: prevent, detect, respond, recover, hardening, monitoring, authentication, authorization, encryption, integrityProtection, audit, updateMechanism.	—
AssetKind	enum def	Controlled values for asset: data, credential, configuration, software, hardware, networkConnection, auditRecord, safetyCriticalFunction.	—
SecurityNeedKind	enum def	How much an asset needs confidentiality, integrity or availability protection. A rating, not prose, so assets can be compared and a rule can select the ones whose integrity need is high.	—
ViewOutputKind	enum def	Controlled values for view output: diagram, table, matrix, documentSection, dashboard.	—
PresentationKind	enum def	Controlled values for presentation: blockDiagram, internalDiagram, activityDiagram, stateDiagram, riskTable, traceMatrix, narrativeSection, screenLayout, custom.	—
DeploymentKind	enum def	Controlled values for deployment: native, containerized, cloudHosted, embedded, partitioned.	—
ContextSideKind	enum def	Which side of a system context diagram a participant belongs on. Animate and inanimate are kept apart because they are governed differently: a human participant carries training and use-error considerations (IEC 62366-1), an external system carries interface and interoperabili…	—
ActorKind	enum def	Controlled values for actor: patient, clinician, caregiver, technician, administrator.	—
ValidationMethodKind	enum def	Controlled values for validation method: clinicalTrial, summativeUsabilityTest, comparativeStudy, benchmarkTest, simulatedUse.	—
SOUPClassificationKind	enum def	Controlled values for soupclassification: classA, classB, classC, unclassified.	—
OperationalEntityKind	enum def	Controlled values for operational entity: human, externalSystem, environmentalEntity, regulatoryBody, device, informationArtifact.	—
FunctionalFlowKind	enum def	Controlled values for functional flow: nominal, error, degraded, alarm, startup, shutdown, calibration.	—
ProcessingNodeKind	enum def	Controlled values for processing node: microcontroller, FPGA, SoC, gateway, cloudServer, edgeDevice, DSP.	—
FailureModeKind	enum def	Controlled values for failure mode: lossOfFunction, degradedFunction, unintendedFunction, intermittentFunction, prematureFunction, delayedFunction.	—
FailureEffectLevelKind	enum def	Controlled values for failure effect level: local, nextHigher, endEffect.	—
FailureCauseCategoryKind	enum def	Controlled values for failure cause category: design, manufacturing, material, wear, misuse, environmental, software.	—
SeverityKind	enum def	Controlled values for severity: negligible, minor, serious, critical, catastrophic.	—
ProbabilityKind	enum def	Qualitative likelihood of occurrence (ISO 14971 / AAMI TIR style Likert scale), used wherever a hazard, failure, or fault-tree event carries a qualitative occurrence estimate rather than a measured rate.	—
DetectionKind	enum def	Qualitative ability to detect a failure/threat before it causes harm — used for FMEA detection ratings and cybersecurity detectability.	—
RiskAcceptabilityKind	enum def	ISO 14971 clause 3.14/8 risk acceptability decision.	—
DetectionMethodKind	enum def	Controlled values for detection method: inspection, testing, monitoring, alarm, userReport, selfDiagnostic, periodicMaintenance.	—
FMEAActionKind	enum def	Controlled values for fmeaaction: designChange, processChange, verificationActivity, labeling, training, monitoring.	—
FaultTreeEventKind	enum def	Controlled values for fault tree event: topEvent, intermediateEvent, basicEvent, undevelopedEvent, houseEvent, externalEvent, conditionalEvent.	—
FaultTreeGateKind	enum def	Controlled values for fault tree gate: andGate, orGate, kOfNGate, xorGate, inhibitGate, priorityAndGate.	—
DesignDecisionStatusKind	enum def	Controlled values for design decision status: proposed, accepted, superseded, rejected.	—
RiskControlImplementationKind	enum def	Controlled values for risk control implementation: hardwareDesign, softwareDesign, labeling, training, proceduralControl.	—
ActionKind	enum def	Controlled values for action: transform, validate, route, store, present, actuate, sense, compute, filtering, encrypt, authenticate.	—
ActivityFlowKind	enum def	Controlled values for activity flow: controlFlow, objectFlow, exceptionFlow.	—
MessageKind	enum def	Controlled values for message: synchronous, asynchronous, reply, create, destroy, timeout.	—
TimingConstraintKind	enum def	Controlled values for timing constraint: deadline, period, jitter, latency, separation, burstInterval.	—
HAZOPGuideWordKind	enum def	Controlled values for hazopguide word: no, more, less, asWellAs, partOf, reverse, other, early, late, before, subsequent.	—
ChangeTypeKind	enum def	Controlled values for change type: corrective, preventive, enhancement, regulatoryDriven.	—
UseErrorCategoryKind	enum def	Controlled values for use error category: perception, cognition, actionCategory, memoryRecall.	—
CommentStatusKind	enum def	Lifecycle of a review remark on a model element. rejected is a closed state with a stated reason, not a deletion: a design review that considered a point and declined it is a record the DHF wants to keep.	—

LegendSourceKind

enum def LegendSourceKind

Property	Value
Description	Where a legend gets the value it colours by, when that value is not stored on the element at all but derived from the model.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

LegendScopeKind

enum def LegendScopeKind

Property	Value
Description	What a legend colours. The values are SysML's own usage keywords, so a renderer matches an element's construct directly rather than translating a private vocabulary into one.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ConcernKind

enum def ConcernKind

Property	Value
Description	Controlled values for concern: safety, usability, cybersecurity, performance, interoperability, reliability, privacy, regulatory, clinical.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RequirementSourceKind

enum def RequirementSourceKind

Property	Value
Description	Controlled values for requirement source: stakeholderNeed, risk, designDecision, changeRequest, sourceDocument, extension.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

NotificationPriorityKind

enum def NotificationPriorityKind

Property	Value
Description	Notification/alarm priority as used by source requirement documents (e.g. CriSys GPCA REQ 59 action table: High/Med/Low).
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RequirementNotationKind

enum def RequirementNotationKind

Property	Value
Description	Controlled values for requirement notation: freeText, ears, sophist, formalConstraint.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

EarsPatternKind

enum def EarsPatternKind

Property	Value
Description	Controlled values for ears pattern: ubiquitous, eventDriven, stateDriven, optionalFeature, unwantedBehavior, complex.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ObligationKind

enum def ObligationKind

Property	Value
Description	Controlled values for obligation: shall, should, will.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

InterfaceKind

enum def InterfaceKind

Property	Value
Description	Controlled values for interface: data, control, analogSignal, digitalSignal, power, network, api, userInteraction, notification, logging, mechanical, fluidic.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

SignalingKind

enum def SignalingKind

Property	Value
Description	Continuous value: the quantity IS the information (a 0.5-4.5 V sensor output, a 4-20 mA loop). Needs a range, accuracy and noise bound.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

PhysicalMediumKind

enum def PhysicalMediumKind

Property	Value
Description	The physical medium a hardware connection runs over.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

PortCategoryKind

enum def PortCategoryKind

Property	Value
Description	Sampled. The reader sees the most recent value; a missed deadline drops a sample and never blocks.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

FlowKind

enum def FlowKind

Property	Value
Description	Controlled values for flow: information, command, status, telemetry, alarm, configuration, measurement, audit, power.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

DirectionKind

enum def DirectionKind

Property	Value
Description	Direction of a flow across a boundary. Track A2 removed this from PORTS: a port usage says in / out / inout natively, which is the language's own spelling and the only one a conforming tool reads.…
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

CriticalityKind

enum def CriticalityKind

Property	Value
Description	Controlled values for criticality: low, medium, high, catastrophic.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

SafetyClassKind

enum def SafetyClassKind

Property	Value
Description	Controlled values for safety class: none, A, B, C.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ComplexityKind

enum def ComplexityKind

Property	Value
Description	Controlled values for complexity: low, medium, high, complex.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

LifecycleStateKind

enum def LifecycleStateKind

Property	Value
Description	Controlled values for lifecycle state: concept, development, released, maintenance, obsolete.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

MemoVerificationMethodKind

enum def MemoVerificationMethodKind

Property	Value
Description	Controlled values for memo verification method: inspection, analytical, demonstration, test, simulation, formalProof, modelChecking.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RegulatoryRegimeKind

enum def RegulatoryRegimeKind

Property	Value
Description	The submission regime a model targets, and the regimes a standard has standing in. This is the axis that decides which clauses a model is required to claim: required(model) is the clauses of every standard whose appliesToRegime intersects the regimes the model's ModelMetho…
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ArtifactKind

enum def ArtifactKind

Property	Value
Description	Controlled values for artifact: plan, requirementSpecification, architectureDescription, softwareDesignDescription, riskRecord, traceMatrix, testProtocol, testReport, evidenceRecord, cybersecurityAssessment, threatModel, usabilityEngineeringReport, clinicalSafetyReport, failureModeEffectsAnalysis, soupList, designInputPlan, designOutputPlan, softwareDevelopmentPlan, labelingSpecification, designHistoryFileIndex, designChangeLog.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RiskControlKind

enum def RiskControlKind

Property	Value
Description	Controlled values for risk control: inherentSafeDesign, protectiveMeasure, informationForSafety, alarm, interlock, monitoring, plausibilityCheck.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

HazardTypeKind

enum def HazardTypeKind

Property	Value
Description	Controlled values for hazard type: drugDeliveryError, energyExposure, informationError, mechanicalFailure, biologicalContamination, softwareAnomaly, useError, environmentalHazard.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

CauseSourceKind

enum def CauseSourceKind

Property	Value
Description	Cause-source categories for hazard causal trees. Mirrors the cause-source tables of the FDA GIIP hazard taxonomy (Zhang et al. 2010, Tables 2-9) and the section headings of the GIP Hazard Analysis v1.0 (Arney et al. 2009, section 2.4.1-2.4.8).
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

PortDisplayKind

enum def PortDisplayKind

Property	Value
Description	Controlled values for port display: everything, ports, hidden.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ConnectionDisplayKind

enum def ConnectionDisplayKind

Property	Value
Description	Controlled values for connection display: summary, everything, hidden.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

DiagramViewKind

enum def DiagramViewKind

Property	Value
Description	Controlled values for diagram view: general, interconnection, actionflow, statetransition, sequence, grid, browser, geometry.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

DocumentViewKind

enum def DocumentViewKind

Property	Value
Description	Controlled values for document view: DHF, SDD, RMF, VV, architectureDescription, cybersecurityAssessment, threatModel, clinical, usability.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

SchedulingPolicyKind

enum def SchedulingPolicyKind

Property	Value
Description	Controlled values for scheduling policy: nonRealTime, roundRobin, fixedPriorityPreemptive, rateMonotonic, deadlineMonotonic, EDF.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

BehaviorPropertyKind

enum def BehaviorPropertyKind

Property	Value
Description	Controlled values for behavior property: stateInvariant, transitionRule, temporalProperty, safetyProperty, livenessProperty, assumption, guarantee.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

InterfaceItemKind

enum def InterfaceItemKind

Property	Value
Description	Controlled values for interface item: data, command, signal, material, energy, fluid, mechanicalForce.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

PropertyLanguageKind

enum def PropertyLanguageKind

Property	Value
Description	Controlled values for property language: naturalLanguage, pseudoFormal, agreeLike, ltlLike, ctlLike.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RuleStrengthKind

enum def RuleStrengthKind

Property	Value
Description	Controlled values for rule strength: optional, recommended, required, forbidden.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RulePredicateKind

enum def RulePredicateKind

Property	Value
Description	Controlled values for rule predicate: requireRelationship, conditionalRequireRelationship, requireAttribute, uniqueAttribute, cardinalityCheck, coverageCheck.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RuleSeverityKind

enum def RuleSeverityKind

Property	Value
Description	Controlled values for rule severity: error, warning, info.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RuleCategoryKind

enum def RuleCategoryKind

Property	Value
Description	Controlled values for rule category: closure, coverage, lifecycle, crossLayer, quantitative.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RuleTailoringKind

enum def RuleTailoringKind

Property	Value
Description	How far a methodology may tailor a rule. invariant rules hold the ontology's own consistency and may only change in an ontology release; assurance and methodology rules may be disabled or replaced through an explicit RulePolicy carrying rationale and authority.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RuleDomainKind

enum def RuleDomainKind

Property	Value
Description	Why a rule exists. modelling rules keep a model well formed whatever the product is. medicalDevice rules exist because a medical-device standard or guidance asks for the thing they check, and each should say which clause it enforces (`#EnforcesClause dependency from …
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RuleObligationKind

enum def RuleObligationKind

Property	Value
Description	How firmly the rule's source asks for what it checks, separate from the severity a finding carries and from how far the rule may be tailored.…
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

WorkspaceMembershipKind

enum def WorkspaceMembershipKind

Property	Value
Description	How a relation places elements in a workspace; see memo_core_relationships_workspace_membership.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RuleDispositionKind

enum def RuleDispositionKind

Property	Value
Description	Controlled values for rule disposition: enabled, disabled, replaced.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ScopeModeKind

enum def ScopeModeKind

Property	Value
Description	Whether a methodology's inclusion lists are the whole selection or a deliberate subset. An empty list under explicit selects nothing; it never means "everything". allAvailable is the only way to say "all", and it is always deliberate.…
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

WorkflowStageKind

enum def WorkflowStageKind

Property	Value
Description	Controlled values for workflow stage: context, requirements, behavior, architecture, interfaces, risk, verificationStage, evidence, documents, operational, functional, logical, physical, humanFactors, security, release.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

MethodLevelKind

enum def MethodLevelKind

Property	Value
Description	The level a method step is worked at: the system of systems, or one system.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ThreatCategoryKind

enum def ThreatCategoryKind

Property	Value
Description	Controlled values for threat category: spoofing, tampering, repudiation, informationDisclosure, denialOfService, elevationOfPrivilege, privacyLoss, supplyChain.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

CyberControlKind

enum def CyberControlKind

Property	Value
Description	Controlled values for cyber control: prevent, detect, respond, recover, hardening, monitoring, authentication, authorization, encryption, integrityProtection, audit, updateMechanism.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

AssetKind

enum def AssetKind

Property	Value
Description	Controlled values for asset: data, credential, configuration, software, hardware, networkConnection, auditRecord, safetyCriticalFunction.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

SecurityNeedKind

enum def SecurityNeedKind

Property	Value
Description	How much an asset needs confidentiality, integrity or availability protection. A rating, not prose, so assets can be compared and a rule can select the ones whose integrity need is high.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ViewOutputKind

enum def ViewOutputKind

Property	Value
Description	Controlled values for view output: diagram, table, matrix, documentSection, dashboard.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

PresentationKind

enum def PresentationKind

Property	Value
Description	Controlled values for presentation: blockDiagram, internalDiagram, activityDiagram, stateDiagram, riskTable, traceMatrix, narrativeSection, screenLayout, custom.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

DeploymentKind

enum def DeploymentKind

Property	Value
Description	Controlled values for deployment: native, containerized, cloudHosted, embedded, partitioned.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ContextSideKind

enum def ContextSideKind

Property	Value
Description	Which side of a system context diagram a participant belongs on. Animate and inanimate are kept apart because they are governed differently: a human participant carries training and use-error considerations (IEC 62366-1), an external system carries interface and interoperabili…
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ActorKind

enum def ActorKind

Property	Value
Description	Controlled values for actor: patient, clinician, caregiver, technician, administrator.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ValidationMethodKind

enum def ValidationMethodKind

Property	Value
Description	Controlled values for validation method: clinicalTrial, summativeUsabilityTest, comparativeStudy, benchmarkTest, simulatedUse.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

SOUPClassificationKind

enum def SOUPClassificationKind

Property	Value
Description	Controlled values for soupclassification: classA, classB, classC, unclassified.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

OperationalEntityKind

enum def OperationalEntityKind

Property	Value
Description	Controlled values for operational entity: human, externalSystem, environmentalEntity, regulatoryBody, device, informationArtifact.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

FunctionalFlowKind

enum def FunctionalFlowKind

Property	Value
Description	Controlled values for functional flow: nominal, error, degraded, alarm, startup, shutdown, calibration.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ProcessingNodeKind

enum def ProcessingNodeKind

Property	Value
Description	Controlled values for processing node: microcontroller, FPGA, SoC, gateway, cloudServer, edgeDevice, DSP.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

FailureModeKind

enum def FailureModeKind

Property	Value
Description	Controlled values for failure mode: lossOfFunction, degradedFunction, unintendedFunction, intermittentFunction, prematureFunction, delayedFunction.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

FailureEffectLevelKind

enum def FailureEffectLevelKind

Property	Value
Description	Controlled values for failure effect level: local, nextHigher, endEffect.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

FailureCauseCategoryKind

enum def FailureCauseCategoryKind

Property	Value
Description	Controlled values for failure cause category: design, manufacturing, material, wear, misuse, environmental, software.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

SeverityKind

enum def SeverityKind

Property	Value
Description	Controlled values for severity: negligible, minor, serious, critical, catastrophic.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ProbabilityKind

enum def ProbabilityKind

Property	Value
Description	Qualitative likelihood of occurrence (ISO 14971 / AAMI TIR style Likert scale), used wherever a hazard, failure, or fault-tree event carries a qualitative occurrence estimate rather than a measured rate.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

DetectionKind

enum def DetectionKind

Property	Value
Description	Qualitative ability to detect a failure/threat before it causes harm — used for FMEA detection ratings and cybersecurity detectability.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RiskAcceptabilityKind

enum def RiskAcceptabilityKind

Property	Value
Description	ISO 14971 clause 3.14/8 risk acceptability decision.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

DetectionMethodKind

enum def DetectionMethodKind

Property	Value
Description	Controlled values for detection method: inspection, testing, monitoring, alarm, userReport, selfDiagnostic, periodicMaintenance.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

FMEAActionKind

enum def FMEAActionKind

Property	Value
Description	Controlled values for fmeaaction: designChange, processChange, verificationActivity, labeling, training, monitoring.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

FaultTreeEventKind

enum def FaultTreeEventKind

Property	Value
Description	Controlled values for fault tree event: topEvent, intermediateEvent, basicEvent, undevelopedEvent, houseEvent, externalEvent, conditionalEvent.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

FaultTreeGateKind

enum def FaultTreeGateKind

Property	Value
Description	Controlled values for fault tree gate: andGate, orGate, kOfNGate, xorGate, inhibitGate, priorityAndGate.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

DesignDecisionStatusKind

enum def DesignDecisionStatusKind

Property	Value
Description	Controlled values for design decision status: proposed, accepted, superseded, rejected.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

RiskControlImplementationKind

enum def RiskControlImplementationKind

Property	Value
Description	Controlled values for risk control implementation: hardwareDesign, softwareDesign, labeling, training, proceduralControl.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ActionKind

enum def ActionKind

Property	Value
Description	Controlled values for action: transform, validate, route, store, present, actuate, sense, compute, filtering, encrypt, authenticate.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ActivityFlowKind

enum def ActivityFlowKind

Property	Value
Description	Controlled values for activity flow: controlFlow, objectFlow, exceptionFlow.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

MessageKind

enum def MessageKind

Property	Value
Description	Controlled values for message: synchronous, asynchronous, reply, create, destroy, timeout.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

TimingConstraintKind

enum def TimingConstraintKind

Property	Value
Description	Controlled values for timing constraint: deadline, period, jitter, latency, separation, burstInterval.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

HAZOPGuideWordKind

enum def HAZOPGuideWordKind

Property	Value
Description	Controlled values for hazopguide word: no, more, less, asWellAs, partOf, reverse, other, early, late, before, subsequent.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

ChangeTypeKind

enum def ChangeTypeKind

Property	Value
Description	Controlled values for change type: corrective, preventive, enhancement, regulatoryDriven.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

UseErrorCategoryKind

enum def UseErrorCategoryKind

Property	Value
Description	Controlled values for use error category: perception, cognition, actionCategory, memoryRecall.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

CommentStatusKind

enum def CommentStatusKind

Property	Value
Description	Lifecycle of a review remark on a model element. rejected is a closed state with a stated reason, not a deletion: a design review that considered a point and declined it is a record the DHF wants to keep.
Kind	enum def
Abstract	No
Specializes	—
Owning package	memo_core_enumerations

Source

core/enumerations/memo_enumerations.sysml

package memo_core_enumerations {
    private import ScalarValues::*;

    // Where a legend gets the value it colours by, when that value is not
    // stored on the element at all but derived from the model.
    enum def LegendSourceKind {
        // Depth in the view's own composition hierarchy: the root is 0, its
        // parts 1, theirs 2. This is what "L0 / L1 / L2" actually means, and
        // the tree already computes it — reading it back out of an id string
        // would make a naming convention load-bearing and break the moment
        // something is renamed or re-parented.
        enum hierarchyDepth;
        // The element's ontology kind, which is a field rather than an
        // attribute — and on a block definition diagram it is usually the only
        // thing worth colouring by, since definitions carry few attributes.
        enum elementKind;
    }

    // What a legend colours. The values are SysML's own usage keywords, so a
    // renderer matches an element's construct directly rather than translating
    // a private vocabulary into one.
    enum def LegendScopeKind {
        // Plural, because `part`, `item`, `port`, `action` and `connection` are
        // SysML keywords and cannot name an enum literal. The renderer maps
        // each to the construct it scopes.
        enum parts;
        enum items;
        enum ports;
        enum actions;
        enum connections;
    }

    enum def ConcernKind {
        enum safety;
        enum usability;
        enum cybersecurity;
        enum performance;
        enum interoperability;
        enum reliability;
        enum privacy;
        enum regulatory;
        enum clinical;
    }
    enum def RequirementSourceKind {
        enum stakeholderNeed;
        enum risk;
        enum designDecision;
        enum changeRequest;
        enum sourceDocument;
        enum extension;
    }
    // Notification/alarm priority as used by source requirement documents
    // (e.g. CriSys GPCA REQ 59 action table: High/Med/Low).
    enum def NotificationPriorityKind {
        enum high;
        enum medium;
        enum low;
    }
    enum def RequirementNotationKind {
        enum freeText;
        enum ears;
        enum sophist;
        enum formalConstraint;
    }
    enum def EarsPatternKind {
        enum ubiquitous;
        enum eventDriven;
        enum stateDriven;
        enum optionalFeature;
        enum unwantedBehavior;
        enum complex;
    }
    enum def ObligationKind {
        enum shall;
        enum should;
        enum will;
    }
    enum def InterfaceKind {
        enum data;
        enum control;
        enum analogSignal;
        enum digitalSignal;
        enum power;
        enum network;
        enum api;
        enum userInteraction;
        enum notification;
        enum logging;
        enum mechanical;
        enum fluidic;
    }
    // How a physical interface encodes what it carries. InterfaceKind says
    // WHAT crosses (data, control, power); this says HOW the signal is
    // represented, which decides what has to be specified about it:
    enum def SignalingKind {
        doc /* Continuous value: the quantity IS the information (a 0.5-4.5 V
             * sensor output, a 4-20 mA loop). Needs a range, accuracy and
             * noise bound. */
        enum analog;
        doc /* Encoded symbols: the information is bits, serial or parallel,
             * framed by a protocol (SPI, CAN, Ethernet). Needs a protocol,
             * a bit rate and a logic level. */
        enum digital;
        doc /* One level means one of two states (a switch contact, an
             * enable line). Needs a logic level and a debounce, not a
             * protocol. */
        enum discrete;
        doc /* The information is in the timing of edges: PWM duty, step and
             * direction, frequency output. Needs a frequency range and a
             * resolution. */
        enum pulse;
        doc /* Power transfer, not signalling: the quantity is delivered for
             * its energy. Needs a rating, not a protocol. */
        enum powerTransfer;
    }
    // The physical medium a hardware connection runs over.
    enum def PhysicalMediumKind {
        enum electrical;
        enum fluidic;
        enum pneumatic;
        enum mechanical;
        enum optical;
        enum acoustic;
        enum thermal;
        enum radioFrequency;
    }
    // AADL (SAE AS5506) port category. Distinct from InterfaceKind, which says
    // WHAT crosses a port; this says HOW it is delivered, and the difference is
    // safety-relevant: when a deadline is missed a `data` port overwrites the
    // last sample and loses it, while an `event` or `eventData` port queues,
    // and a queue that outgrows its bound is a different failure with a
    // different mitigation. MEMO carried the distinction on items and not on
    // ports, so neither failure could be argued about at the boundary where it
    // happens.
    enum def PortCategoryKind {
        doc /* Sampled. The reader sees the most recent value; a missed
             * deadline drops a sample and never blocks. */
        enum data;
        doc /* Queued signal with no payload. A missed deadline grows the
             * queue; overflow is the failure to bound.
             *
             * Quoted because `event` is reserved in SysML v2 — the same
             * treatment GovernKind's `'use'` already gets. AADL's word is kept
             * rather than paraphrased to `queued`: it is the term the standard
             * and every AADL tool use, and a renamed one would not survive a
             * round trip. */
        enum 'event';
        doc /* Queued signal carrying a payload — the queueing semantics of
             * `event` with the value of `data`. */
        enum eventData;
    }
    enum def FlowKind {
        enum information;
        enum command;
        enum status;
        enum telemetry;
        enum alarm;
        enum configuration;
        enum measurement;
        enum audit;
        enum power;
    }
    // Direction of a flow across a boundary.
    //
    // Track A2 removed this from PORTS: a port usage says `in` / `out` /
    // `inout` natively, which is the language's own spelling and the only one
    // a conforming tool reads. The enum survives because three non-port
    // constructs still carry a direction and none of them is a port, so none
    // of them can use the keyword:
    //
    //   Interface.direction / .directionality   (interface def)
    //   LogicalConnector.direction              (connection def)
    //   OperationalInteraction.direction        (part def)
    //
    // Deleting it would have cost those three their direction; the reinvention
    // was only ever the port case. `LogicalExchange.direction` was a fourth and
    // went when the exchange became a flow between ports (2026-09-25), and
    // `ComponentExchange.direction` a fifth when the ports at its ends were held to
    // say it (2026-10-25, rule AR-EXCH-002).
    enum def DirectionKind {
        enum input;
        enum output;
        enum inputOutput;
    }
    enum def CriticalityKind {
        enum low;
        enum medium;
        enum high;
        enum catastrophic;
    }
    enum def SafetyClassKind {
        enum none;
        enum A;
        enum B;
        enum C;
    }
    enum def ComplexityKind {
        enum low;
        enum medium;
        enum high;
        enum complex;
    }
    enum def LifecycleStateKind {
        enum concept;
        enum development;
        enum released;
        enum maintenance;
        enum obsolete;
    }
    enum def MemoVerificationMethodKind {
        enum inspection;
        enum analytical;
        enum demonstration;
        enum test;
        enum simulation;
        enum formalProof;
        enum modelChecking;
    }
    // The submission regime a model targets, and the regimes a standard has
    // standing in. This is the axis that decides which clauses a model is
    // required to claim: `required(model)` is the clauses of every standard
    // whose `appliesToRegime` intersects the regimes the model's
    // ModelMethodBinding declares.
    //
    // The members are spelled as the regulatory designations themselves rather
    // than in the lowerCamel convention the rest of this file uses. All 44 DHF
    // templates already carry these exact strings in `required_for`, and any
    // transformation between the enum and those arrays would be a hardcoded
    // spelling map in TypeScript — the one thing the standards axis exists to
    // avoid. One vocabulary, one spelling, declared here.
    enum def RegulatoryRegimeKind {
        enum CE;
        enum MDR;
        enum UKCA;
        enum FDA_510k;
        enum FDA_PMA;
    }
    enum def ArtifactKind {
        enum plan;
        enum requirementSpecification;
        enum architectureDescription;
        enum softwareDesignDescription;
        enum riskRecord;
        enum traceMatrix;
        enum testProtocol;
        enum testReport;
        enum evidenceRecord;
        enum cybersecurityAssessment;
        enum threatModel;
        enum usabilityEngineeringReport;
        enum clinicalSafetyReport;
        enum failureModeEffectsAnalysis;
        enum soupList;
        enum designInputPlan;
        enum designOutputPlan;
        enum softwareDevelopmentPlan;
        enum labelingSpecification;
        enum designHistoryFileIndex;
        enum designChangeLog;
    }
    enum def RiskControlKind {
        enum inherentSafeDesign;
        enum protectiveMeasure;
        enum informationForSafety;
        enum alarm;
        enum interlock;
        enum monitoring;
        enum plausibilityCheck;
    }
    enum def HazardTypeKind {
        enum drugDeliveryError;
        enum energyExposure;
        enum informationError;
        enum mechanicalFailure;
        enum biologicalContamination;
        enum softwareAnomaly;
        enum useError;
        enum environmentalHazard;
    }
    // Cause-source categories for hazard causal trees. Mirrors the
    // cause-source tables of the FDA GIIP hazard taxonomy (Zhang et al.
    // 2010, Tables 2-9) and the section headings of the GIP Hazard
    // Analysis v1.0 (Arney et al. 2009, section 2.4.1-2.4.8).
    enum def CauseSourceKind {
        enum operational;
        enum environmental;
        enum electrical;
        enum hardware;
        enum software;
        enum mechanical;
        enum biologicalChemical;
        enum usageCause;
    }
    // The eight standard SysML v2 view kinds (spec taxonomy). Every
    // diagram view resolves to exactly one of these (Epic KK).
    // How much of an interconnection drawing's port and connector detail is
    // shown. Declared on the view, because how much detail a drawing carries
    // is part of what the drawing IS — a summary IBD and a fully expanded one
    // answer different questions about the same elements.
    // `everything` and `hidden`, not `all` and `none`: both of those are SysML
    // keywords and a literal cannot be named one — the same reason
    // LegendScopeKind is plural. The renderer maps each to the display mode it
    // names.
    enum def PortDisplayKind {
        enum everything;
        enum ports;
        enum hidden;
    }

    enum def ConnectionDisplayKind {
        enum summary;
        enum everything;
        enum hidden;
    }

    enum def DiagramViewKind {
        enum general;
        enum interconnection;
        enum actionflow;
        enum statetransition;
        enum sequence;
        enum grid;
        enum browser;
        enum geometry;
    }
    enum def DocumentViewKind {
        enum DHF;
        enum SDD;
        enum RMF;
        enum VV;
        enum architectureDescription;
        enum cybersecurityAssessment;
        enum threatModel;
        enum clinical;
        enum usability;
    }
    enum def SchedulingPolicyKind {
        enum nonRealTime;
        enum roundRobin;
        enum fixedPriorityPreemptive;
        enum rateMonotonic;
        enum deadlineMonotonic;
        enum EDF;
    }
    enum def BehaviorPropertyKind {
        enum stateInvariant;
        enum transitionRule;
        enum temporalProperty;
        enum safetyProperty;
        enum livenessProperty;
        enum assumption;
        enum guarantee;
    }
    enum def InterfaceItemKind {
        enum data;
        enum command;
        enum signal;
        enum 'event';
        enum material;
        enum energy;
        enum fluid;
        enum mechanicalForce;
    }
    enum def PropertyLanguageKind {
        enum naturalLanguage;
        enum pseudoFormal;
        enum agreeLike;
        enum ltlLike;
        enum ctlLike;
    }
    enum def RuleStrengthKind {
        enum optional;
        enum recommended;
        enum required;
        enum forbidden;
    }
    enum def RulePredicateKind {
        enum requireRelationship;
        enum conditionalRequireRelationship;
        enum requireAttribute;
        enum uniqueAttribute;
        enum cardinalityCheck;
        enum coverageCheck;
    }
    enum def RuleSeverityKind {
        enum error;
        enum warning;
        enum info;
    }
    enum def RuleCategoryKind {
        enum closure;
        enum coverage;
        enum lifecycle;
        enum crossLayer;
        enum quantitative;
    }
    // How far a methodology may tailor a rule. `invariant` rules hold the
    // ontology's own consistency and may only change in an ontology release;
    // `assurance` and `methodology` rules may be disabled or replaced through
    // an explicit RulePolicy carrying rationale and authority.
    enum def RuleTailoringKind {
        enum invariant;
        enum assurance;
        enum methodology;
    }
    // Why a rule exists. `modelling` rules keep a model well formed whatever the
    // product is. `medicalDevice` rules exist because a medical-device standard or
    // guidance asks for the thing they check, and each should say which clause it
    // enforces (`#EnforcesClause dependency from <rule> to <clause>`). `organisation` rules are a user's own.
    enum def RuleDomainKind {
        enum modelling;
        enum medicalDevice;
        enum organisation;
    }
    // How firmly the rule's source asks for what it checks, separate from the
    // severity a finding carries and from how far the rule may be tailored. A
    // `required` rule enforces a clause that says "shall"; a `recommended` one a
    // clause that says "should", or a practice the ontology holds as sound;
    // `bestPractice` is advice with no clause behind it. A rule that states no
    // severity takes one from this: error, warning, info.
    enum def RuleObligationKind {
        enum required;
        enum recommended;
        enum bestPractice;
    }
    // How a relation places elements in a workspace; see
    // memo_core_relationships_workspace_membership.
    enum def WorkspaceMembershipKind {
        enum sourceFollowsTarget;
        enum targetFollowsSource;
        enum neither;
    }
    enum def RuleDispositionKind {
        enum enabled;
        enum disabled;
        enum replaced;
    }
    // Whether a methodology's inclusion lists are the whole selection or a
    // deliberate subset. An empty list under `explicit` selects nothing; it
    // never means "everything". `allAvailable` is the only way to say "all",
    // and it is always deliberate. (SysML v2 reserves `all`, so the literal is
    // spelled `allAvailable`.)
    enum def ScopeModeKind {
        enum allAvailable;
        enum explicit;
    }
    enum def WorkflowStageKind {
        enum context;
        enum requirements;
        enum behavior;
        enum architecture;
        enum interfaces;
        enum risk;
        enum verificationStage;
        enum evidence;
        enum documents;
        // The stages of the default method's steps (plan O11), beyond the six above.
        enum operational;
        enum functional;
        enum logical;
        enum physical;
        enum humanFactors;
        enum security;
        enum release;
    }
    // The level a method step is worked at: the system of systems, or one system.
    enum def MethodLevelKind {
        enum systemOfSystems;
        enum system;
    }
    enum def ThreatCategoryKind {
        enum spoofing;
        enum tampering;
        enum repudiation;
        enum informationDisclosure;
        enum denialOfService;
        enum elevationOfPrivilege;
        enum privacyLoss;
        enum supplyChain;
    }
    enum def CyberControlKind {
        enum prevent;
        enum detect;
        enum respond;
        enum recover;
        enum hardening;
        enum monitoring;
        enum authentication;
        enum authorization;
        enum encryption;
        enum integrityProtection;
        enum audit;
        enum updateMechanism;
    }
    enum def AssetKind {
        enum data;
        enum credential;
        enum configuration;
        enum software;
        enum hardware;
        enum networkConnection;
        enum auditRecord;
        enum safetyCriticalFunction;
    }
    // How much an asset needs confidentiality, integrity or availability
    // protection. A rating, not prose, so assets can be compared and a rule
    // can select the ones whose integrity need is high.
    enum def SecurityNeedKind {
        enum low;
        enum medium;
        enum high;
        enum veryHigh;
    }
    enum def ViewOutputKind {
        enum diagram;
        enum table;
        enum matrix;
        enum documentSection;
        enum dashboard;
    }
    enum def PresentationKind {
        enum blockDiagram;
        enum internalDiagram;
        enum activityDiagram;
        enum stateDiagram;
        enum riskTable;
        enum traceMatrix;
        enum narrativeSection;
        // A captured screen with its regions drawn over it — the presentation
        // of the geometry view kind.
        enum screenLayout;
        enum custom;
    }
    enum def DeploymentKind {
        enum native;
        enum containerized;
        enum cloudHosted;
        enum embedded;
        enum partitioned;
    }
    // Which side of a system context diagram a participant belongs on.
    // Animate and inanimate are kept apart because they are governed
    // differently: a human participant carries training and use-error
    // considerations (IEC 62366-1), an external system carries interface and
    // interoperability ones.
    enum def ContextSideKind {
        // A human who interacts with the device (IEC 62366-1 intended user).
        enum 'actor';
        // An inanimate external system, device, or supply the device exchanges with.
        enum externalSystem;
        // The setting the device sits inside (IEC 62366-1 3.20 use environment).
        enum environment;
        // A condition the context imposes rather than a thing it connects to —
        // regulatory, clinical, or operational limits on use.
        enum 'constraint';
    }
    enum def ActorKind {
        enum patient;
        enum clinician;
        enum caregiver;
        enum technician;
        enum administrator;
    }
    enum def ValidationMethodKind {
        enum clinicalTrial;
        enum summativeUsabilityTest;
        enum comparativeStudy;
        enum benchmarkTest;
        enum simulatedUse;
    }
    enum def SOUPClassificationKind {
        enum classA;
        enum classB;
        enum classC;
        enum unclassified;
    }
    enum def OperationalEntityKind {
        enum human;
        enum externalSystem;
        enum environmentalEntity;
        enum regulatoryBody;
        enum device;
        enum informationArtifact;
    }
    enum def FunctionalFlowKind {
        enum nominal;
        enum error;
        enum degraded;
        enum alarm;
        enum startup;
        enum shutdown;
        enum calibration;
    }
    enum def ProcessingNodeKind {
        enum microcontroller;
        enum FPGA;
        enum SoC;
        enum gateway;
        enum cloudServer;
        enum edgeDevice;
        enum DSP;
    }
    enum def FailureModeKind {
        enum lossOfFunction;
        enum degradedFunction;
        enum unintendedFunction;
        enum intermittentFunction;
        enum prematureFunction;
        enum delayedFunction;
    }
    enum def FailureEffectLevelKind {
        enum local;
        enum nextHigher;
        enum endEffect;
    }
    enum def FailureCauseCategoryKind {
        enum design;
        enum manufacturing;
        enum material;
        enum wear;
        enum misuse;
        enum environmental;
        enum software;
    }
    // ISO 14971 severity of harm — distinct from the general-purpose
    // CriticalityKind used elsewhere for architecture/software criticality.
    enum def SeverityKind {
        enum negligible;
        enum minor;
        enum serious;
        enum critical;
        enum catastrophic;
    }
    // Qualitative likelihood of occurrence (ISO 14971 / AAMI TIR style
    // Likert scale), used wherever a hazard, failure, or fault-tree event
    // carries a qualitative occurrence estimate rather than a measured rate.
    enum def ProbabilityKind {
        enum incredible;
        enum improbable;
        enum remote;
        enum occasional;
        enum probable;
        enum frequent;
    }
    // Qualitative ability to detect a failure/threat before it causes harm —
    // used for FMEA detection ratings and cybersecurity detectability.
    enum def DetectionKind {
        enum high;
        enum moderate;
        enum low;
        enum none;
    }
    // ISO 14971 clause 3.14/8 risk acceptability decision.
    enum def RiskAcceptabilityKind {
        enum acceptable;
        enum alarp;
        enum unacceptable;
    }
    enum def DetectionMethodKind {
        enum inspection;
        enum testing;
        enum monitoring;
        enum alarm;
        enum userReport;
        enum selfDiagnostic;
        enum periodicMaintenance;
    }
    enum def FMEAActionKind {
        enum designChange;
        enum processChange;
        enum verificationActivity;
        enum labeling;
        enum training;
        enum monitoring;
    }
    enum def FaultTreeEventKind {
        enum topEvent;
        enum intermediateEvent;
        enum basicEvent;
        enum undevelopedEvent;
        enum houseEvent;
        enum externalEvent;
        enum conditionalEvent;
    }
    enum def FaultTreeGateKind {
        enum andGate;
        enum orGate;
        enum kOfNGate;
        enum xorGate;
        enum inhibitGate;
        enum priorityAndGate;
    }
    enum def DesignDecisionStatusKind {
        enum proposed;
        enum accepted;
        enum superseded;
        enum rejected;
    }
    enum def RiskControlImplementationKind {
        enum hardwareDesign;
        enum softwareDesign;
        enum labeling;
        enum training;
        enum proceduralControl;
    }
    enum def ActionKind {
        enum transform;
        enum validate;
        enum route;
        enum store;
        enum present;
        enum actuate;
        enum sense;
        enum compute;
        enum filtering;
        enum encrypt;
        enum authenticate;
    }
    enum def ActivityFlowKind {
        enum controlFlow;
        enum objectFlow;
        enum exceptionFlow;
    }
    enum def MessageKind {
        enum synchronous;
        enum asynchronous;
        enum reply;
        enum create;
        enum destroy;
        enum timeout;
    }
    enum def TimingConstraintKind {
        enum deadline;
        enum period;
        enum jitter;
        enum latency;
        enum separation;
        enum burstInterval;
    }
    enum def HAZOPGuideWordKind {
        enum no;
        enum more;
        enum less;
        enum asWellAs;
        enum partOf;
        enum reverse;
        enum other;
        enum early;
        enum late;
        enum before;
        enum subsequent;
    }
    enum def ChangeTypeKind {
        enum corrective;
        enum preventive;
        enum enhancement;
        enum regulatoryDriven;
    }
    enum def UseErrorCategoryKind {
        enum perception;
        enum cognition;
        enum actionCategory;
        enum memoryRecall;
    }
    // Lifecycle of a review remark on a model element. `rejected` is a closed
    // state with a stated reason, not a deletion: a design review that
    // considered a point and declined it is a record the DHF wants to keep.
    enum def CommentStatusKind {
        enum open;
        enum acknowledged;
        enum addressed;
        enum resolved;
        enum rejected;
    }
}