mbse-metamodel.graphql

schema {
  query: Query
  mutation: Mutation
}
type Query {
  """
  List of Projects
  """
  cpsProjectsQuery: ProjectsResponse
  """
  System Model for: 'Essentials' Facility
  """
  cpsSystemModelQuery(projectId: ID!): CPSsystemModelResponse
}
type ProjectsResponse {
  status: ResponseStatus
  projects: [Project]
}
type CPSsystemModelResponse
{
  status: ResponseStatus
  cpsSystemModel: CPSsystemModel
}
type CPSsystemModel {
  """
  The project identity.
  """
  project: Project

  """
  A component is an abstract term that represents the physical or logical entity
  that performs a specific function or functions.
  """
  component: [Component]

  """
  A document identifies either the source/authorization for information entered
  into the system description database, a specification/document generated from
  the contents of the database, or an applicable or reference document for a
  specification/document generated from the contents of the database.
  """
  document: [Document]

  """
  A Function is a transformation that accepts one or more inputs (items) and
  transforms them into outputs (items).
  """
  function: [Function]

  """
  Items represent flows within and between functions. An item is an input to or an
  output from a function.
  """
  item: [Item]

  """
  A link is the physical implementation of an interface.
  """
  link: [Link]

  """
  An organization identifies an individual or organizational unit.
  """
  organization: [Organization]

  """
  A Requirement is either an originating requirement extracted from source
  documentation for a system, a refinement of a higher-level requirement, a
  derived characteristic of the system or one of its subcomponents, or a design
  decision.
  """
  requirement: [Requirement]

  """
  A Risk is the uncertainty of attaining or achieving a product or program
  milestone. It is described by a combination of the probability that the risk
  event will occur and the consequence of the extent of loss from the occurrence,
  or impact. Risk is an inherent part of all activities, whether the activity is
  simple and small, or large and complex.
  """
  risk: [Risk]

  """
  A use case entity identifies a piece of the functionality of a system in terms
  of how the users use the system to achieve their goals. Use cases are high-level
  descriptions of behavior under a specific set of conditions. These high-level
  descriptions can then be elaborated to define the system behavior.
  """
  useCase: [UseCase]

  """
  A VerificationRequirement describes what is to be proved (i.e., requirements),
  at what level the verification will occur, which method of verification should
  be used, and the current verification status.
  """
  verificationRequirement: [VerificationRequirement]

  """
  recursive call structure (select, parallel, loop, etc.) for each function
  """
  callStructure: [CallStructure]
}

type Mutation {
  """
  Mutate Project
  """
  cpsProjectMutation(project: Project_Input): ProjectResponse
  """
  Mutate CPS System Model
  """
  cpsSystemModelMutation(projectId: ID!, cpsSystemModel: CPSsystemModel_Input): CPSsystemModelResponse
}

type ProjectResponse {
  status: ResponseStatus
  project: Project
}
input CPSsystemModel_Input {
  component: [Component_Input]
  document: [Document_Input]
  function: [Function_Input]
  item: [Item_Input]
  link: [Link_Input]
  organization: [Organization_Input]
  requirement: [Requirement_Input]
  risk: [Risk_Input]
  useCase: [UseCase_Input]
  verificationRequirement: [VerificationRequirement_Input]
}

#########################################
# Common Definitions
#########################################
type ResponseStatus {
  code: ResponseCode
  message: String
}
enum ResponseCode
{
  Success
  FailureNotFound
  FailureNotUnique
 FailureGeneral
}
type Project {
  id: ID!
  name: String!
  description: String
  version: String
}
# for mutations
input Project_Input {
  operation: MutationOperation!
  id: ID # autogenerated on Create, required for Update / Delete
  name: String!
  description: String
  version: String
}
type Parameter {
  name: String!
  description: String
  objective: String
  threshold: String
  design: String
  observed: String
  units: String
}
input Parameter_Input {
  operation: MutationOperation!
  name: String!
  description: String
  objective: String
  threshold: String
  design: String
  observed: String
  units: String
}
"""
Mutations for List items of an Entity (Parameters, Relations) include an 'instance' operation.
NOTE: when 'creating' an Entity, all associated List item instances must be set to 'Create'
      when 'updating' an Entity, only include associated List items to be 'Created', 'Updated', or 'Deleted'
      when 'deleting' an Entity, all associated List items are automatically deleted
"""
enum MutationOperation
{
  Create
  Update
  Delete
}
#########################################
# Component definition
#########################################
type Component {
  identity: ComponentID!
  attributes: ComponentATTR
  parameters: [Parameter]
  relations: ComponentREL
}
# for mutations
input Component_Input {
  operation: MutationOperation!
  identity: ComponentID_Input!
  attributes: ComponentATTR_Input
  parameters: [Parameter_Input]
  relations: ComponentREL_Input
}
type ComponentID {
  id: ID!
  name: String!
  number: String!
}
# for mutations
input ComponentID_Input {
  id: ID # autogenerated on Create, required for Update / Delete
  name: String!
  number: String!
}
type ComponentATTR {
  """
  Type identifies the component's role in the component hierarchy.
  """
  type: ComponentType

  """
  Contract Line Item Number is a reference to the contract's identification for
  the specific items and services requiring separate pricing.
  """
  clin: String

  """
  Mission is the text description of the business purpose of a system.
  """
  mission: String

  """
  Operations describe synchronous interactions where the requestor waits for the
  request to be handled. This attribute identifies a subset of the allocated
  behavior that is critical to highlight on SysML representations.
  """
  operations: [String]

  """
  Doc. PUID is the project unique identifier that is often used in system
  development specifications and documents to identify the same entity in multiple
  documents. This is not to be confused with the database entity unique
  identifier.
  """
  puid: String

  """
  Purpose is a brief statement of the reason for the existence of the entity.
  """
  purpose: String

  """
  Receptions describe asynchronous interactions where the requestor can continue
  without waiting for a reply. This attribute identifies a subset of the allocated
  behavior that is critical to highlight on SysML representations.
  """
  receptions: [String]

  """
  Abbreviation identifies a unique shortened name for the entity.
  """
  abbreviation: String

  """
  Title is the label to be used in formal documentation instead of the entity
  name.
  """
  title: String

  """
  Description is the written statement of this entity.
  """
  description: String

}
enum ComponentType {
  nil
  Assembly
  Context
  CSC
  CSCI
  CSU
  Element
  Environment
  External_System
  Facility
  Family_of_Systems
  Human
  HW_Element
  HWCI
  Network
  Part
  Segment
  Service
  Software_Item
  Subassembly
  Subsystem
  SW_Element
  SWCI
  System
  System_Architecture
  System_of_Systems
  Test_Equipment
  Test_Software
}
# for mutations
input ComponentATTR_Input {
  type: ComponentType
  clin: String
  mission: String
  operations: [String]
  puid: String
  purpose: String
  receptions: [String]
  abbreviation: String
  title: String
  description: String
}
type ComponentREL {
  """
  Assigned to identifies a source entity being overseen or controlled by the
  target entity.
  """
  assignedTo: [Component_AssignedToTarget]

  """
  Built from identifies the entities (children) that make up this entity (the
  parent).
  """
  builtFrom: [Component_BuiltFromTarget]

  """
  Built in identifies the parent entity for which this entity is a part.
  """
  builtIn: [Component_BuiltInTarget]

  """
  Causes identifies the technical or programmatic risk resulting from this entity.
  """
  causes: [Component_CausesTarget]

  """
  Connected to identifies the connection that serves to link this unit to another
  entity.
  """
  connectedTo: [Component_ConnectedToTarget]

  """
  Described by identifies the use cases that reflect how the users will use this
  entity to achieve their physical objectives.
  """
  describedBy: [Component_DescribedByTarget]

  """
  Documented by identifies the source document which specifies and/or enhances the
  definition of this entity.
  """
  documentedBy: [Component_DocumentedByTarget]

  """
  Generalization of associates a specific object classification with a more
  general object classification. For example, "Vehicle" is a generalization of
  "Car," "Train," and "Plane."
  """
  generalizationOf: [Component_GeneralizationOfTarget]

  """
  Impacted by identifies the entity that is affected by the risk.
  """
  impactedBy: [Component_ImpactedByTarget]

  """
  Kind of indicates classification. This relationship is often referred to as the
  "is a" relationship (i.e., a car "is a" vehicle).
  """
  kindOf: [Component_KindOfTarget]

  """
  Participates in identifies the use cases that this actor supports.
  """
  participatesIn: [Component_ParticipatesInTarget]

  """
  Performs identifies the actions that this entity accomplishes.
  """
  performs: [Component_PerformsTarget]

  """
  Reported by identifies the documentation entity of which the entity is the
  primary subject.
  """
  reportedBy: [Component_ReportedByTarget]

  """
  Specified by identifies constraint and/or performance requirements that this
  entity must satisfy.
  """
  specifiedBy: [Component_SpecifiedByTarget]

  """
  Verified by points to the method of requirement proof which specifies the
  verification technique, level, and status.
  """
  verifiedBy: [Component_VerifiedByTarget]

}
# for mutations
input ComponentREL_Input {
  assignedTo: [Component_AssignedToTarget_Input]
  builtFrom: [Component_BuiltFromTarget_Input]
  builtIn: [Component_BuiltInTarget_Input]
  causes: [Component_CausesTarget_Input]
  connectedTo: [Component_ConnectedToTarget_Input]
  describedBy: [Component_DescribedByTarget_Input]
  documentedBy: [Component_DocumentedByTarget_Input]
  generalizationOf: [Component_GeneralizationOfTarget_Input]
  impactedBy: [Component_ImpactedByTarget_Input]
  kindOf: [Component_KindOfTarget_Input]
  participatesIn: [Component_ParticipatesInTarget_Input]
  performs: [Component_PerformsTarget_Input]
  reportedBy: [Component_ReportedByTarget_Input]
  specifiedBy: [Component_SpecifiedByTarget_Input]
  verifiedBy: [Component_VerifiedByTarget_Input]
}
type Component_AssignedToTarget {
  organizationTarget: OrganizationID
}
type Component_BuiltFromTarget {
  componentTarget: ComponentID
  """
  Whole Multiplicity indicates if the component is distinct and separable
  (wholeMultiplicity = 0; also termed composition) or whether the component is
  distinct and not separable (wholeMultiplicity = 1; also termed aggregation).
  """
  wholeMultiplicity: Component_BuiltFromWholeMultiplicity

  """
  PartRole is the name of the role that the part plays in the whole.
  """
  partRole: String

  """
  PartMultiplicity is the potential number of instances of the part built in the
  whole. This can be specified as zero, a whole number, or a range from a lower
  bound to an upper bound.
  """
  partMultiplicity: String

}
enum Component_BuiltFromWholeMultiplicity {
  E_0
  E_1
}
type Component_BuiltInTarget {
  componentTarget: ComponentID
  """
  Whole Multiplicity indicates if the component is distinct and separable
  (wholeMultiplicity = 0; also termed composition) or whether the component is
  distinct and not separable (wholeMultiplicity = 1; also termed aggregation).
  """
  wholeMultiplicity: Component_BuiltInWholeMultiplicity

  """
  PartRole is the name of the role that the part plays in the whole.
  """
  partRole: String

  """
  PartMultiplicity is the potential number of instances of the part built in the
  whole. This can be specified as zero, a whole number, or a range from a lower
  bound to an upper bound.
  """
  partMultiplicity: String

}
enum Component_BuiltInWholeMultiplicity {
  E_0
  E_1
}
type Component_CausesTarget {
  riskTarget: RiskID
}
type Component_ConnectedToTarget {
  linkTarget: LinkID
  """
  Port ID provides a unique identification for the port that is used between the
  Link and the Component.
  """
  portID: String

}
type Component_DescribedByTarget {
  useCaseTarget: UseCaseID
}
type Component_DocumentedByTarget {
  documentTarget: DocumentID
}
type Component_GeneralizationOfTarget {
  componentTarget: ComponentID
  """
  Type classifies the nature of the generalization / specialization relationship.
  Inheritance indicates that the specialization shares the properties of the
  generalization. Instance indicates that the specialization also shares the
  relationships of the generalization.
  """
  type: Component_GeneralizationOfType

}
enum Component_GeneralizationOfType {
  Inheritance
  Instance
}
type Component_ImpactedByTarget {
  riskTarget: RiskID
}
type Component_KindOfTarget {
  componentTarget: ComponentID
  """
  Type classifies the nature of the generalization / specialization relationship.
  Inheritance indicates that the specialization shares the properties of the
  generalization. Instance indicates that the specialization also shares the
  relationships of the generalization.
  """
  type: Component_KindOfType

}
enum Component_KindOfType {
  Inheritance
  Instance
}
type Component_ParticipatesInTarget {
  useCaseTarget: UseCaseID
}
type Component_PerformsTarget {
  functionTarget: FunctionID
  """
  Behavior Type classifies the mapping of the processing unit to the
  implementation unit.
  """
  behaviorType: Component_PerformsBehaviorType

}
enum Component_PerformsBehaviorType {
  Atomic
  Integrated_Root
  Thread
}
type Component_ReportedByTarget {
  documentTarget: DocumentID
}
type Component_SpecifiedByTarget {
  requirementTarget: RequirementID
  """
  The Governs relationship attribute identifies the Parameter attribute that is
  associated in both the Requirement entity and Component entity joined by the
  specified by / specifies relationship.
  """
  governs: String

}
type Component_VerifiedByTarget {
  verificationRequirementTarget: VerificationRequirementID
}
# for mutations
input Component_AssignedToTarget_Input {
  operation: MutationOperation!
  organizationTarget: OrganizationID_Input
}
input Component_BuiltFromTarget_Input {
  operation: MutationOperation!
  componentTarget: ComponentID_Input
  wholeMultiplicity: Component_BuiltFromWholeMultiplicity
  partRole: String
  partMultiplicity: String
}
input Component_BuiltInTarget_Input {
  operation: MutationOperation!
  componentTarget: ComponentID_Input
  wholeMultiplicity: Component_BuiltInWholeMultiplicity
  partRole: String
  partMultiplicity: String
}
input Component_CausesTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Component_ConnectedToTarget_Input {
  operation: MutationOperation!
  linkTarget: LinkID_Input
  portID: String
}
input Component_DescribedByTarget_Input {
  operation: MutationOperation!
  useCaseTarget: UseCaseID_Input
}
input Component_DocumentedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Component_GeneralizationOfTarget_Input {
  operation: MutationOperation!
  componentTarget: ComponentID_Input
  type: Component_GeneralizationOfType
}
input Component_ImpactedByTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Component_KindOfTarget_Input {
  operation: MutationOperation!
  componentTarget: ComponentID_Input
  type: Component_KindOfType
}
input Component_ParticipatesInTarget_Input {
  operation: MutationOperation!
  useCaseTarget: UseCaseID_Input
}
input Component_PerformsTarget_Input {
  operation: MutationOperation!
  functionTarget: FunctionID_Input
  behaviorType: Component_PerformsBehaviorType
}
input Component_ReportedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Component_SpecifiedByTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
  governs: String
}
input Component_VerifiedByTarget_Input {
  operation: MutationOperation!
  verificationRequirementTarget: VerificationRequirementID_Input
}
#########################################
# Document definition
#########################################
type Document {
  identity: DocumentID!
  attributes: DocumentATTR
  parameters: [Parameter]
  relations: DocumentREL
}
# for mutations
input Document_Input {
  operation: MutationOperation!
  identity: DocumentID_Input!
  attributes: DocumentATTR_Input
  parameters: [Parameter_Input]
  relations: DocumentREL_Input
}
type DocumentID {
  id: ID!
  name: String!
  number: String!
}
# for mutations
input DocumentID_Input {
  id: ID # autogenerated on Create, required for Update / Delete
  name: String!
  number: String!
}
type DocumentATTR {
  """
  Document Date is the document's publication date.
  """
  documentDate: String

  """
  Non-Govt. Category specifies the heading for non-government applicable
  documents. For example, SPECIFICATIONS is a heading under which this reference
  document will be listed.
  """
  nonGovernmentCategory: DocumentNonGovernmentCategory

  """
  Contract Line Item Number is a reference to the contract's identification for
  the specific items and services requiring separate pricing.
  """
  clin: String

  """
  External File Path contains the external file reference in either standard
  (c:/myDirectory/mySubDirectory/filename) or UNC (//Server/directory/filename)
  format.
  """
  externalFilePath: String

  """
  Document Number is the reference number assigned to the document.
  """
  documentNumber: String

  """
  Title is the label to be used for the document title instead of one derived by
  the script when generating a document from the database.
  """
  title: String

  """
  Contains a full summarization of the system's capabilities, functions, or
  features within this document.
  """
  identification: String

  """
  Govt. Category specifies the headings/subheadings for government applicable
  documents. For example, SPECIFICATIONS is a heading and Military is the
  subheading under which this reference document will be listed.
  """
  governmentCategory: DocumentGovernmentCategory

  """
  Provides a value representing the current level of cumulative document changes.
  """
  revisionNumber: String

  """
  CDRL Number is the contract deliverable identifier for the document.
  """
  cdrlNumber: String

  """
  Summarizes the purpose and contents of this document and also describes any
  security or privacy considerations associated with its use.
  """
  documentOverview: String

  """
  Doc. Report designates which formal documentation report is used to generate
  this document.
  """
  documentScript: DocumentDocumentScript

  """
  Type identifies the type of document.
  """
  type: DocumentType

  """
  Contains the contextual framework or extent of this document's information
  content.
  """
  scope: String

  """
  Description is the written statement of this entity.
  """
  description: String

}
enum DocumentNonGovernmentCategory {
  nil
  SPECIFICATIONS
  STANDARDS
  DRAWINGS
  OTHER_PUBLICATIONS
}
enum DocumentGovernmentCategory {
  nil
  SPECIFICATIONS_Military
  SPECIFICATIONS_Federal
  SPECIFICATIONS_Other_Government_Agency
  STANDARDS_Military
  STANDARDS_Federal
  STANDARDS_Other_Government_Agency
  DRAWINGS
  OTHER_PUBLICATIONS_Manual
  OTHER_PUBLICATIONS_Regulation
  OTHER_PUBLICATIONS_Handbook
  OTHER_PUBLICATIONS_Bulletin
  OTHER_PUBLICATIONS_Other
}
enum DocumentDocumentScript {
  nil
  IRS
  SRS
  Other
  SSDD
  SSS
  TEP
}
enum DocumentType {
  nil
  Agreement
  Change_Notice
  Change_Request
  Drawing
  Goal
  Guidance
  Information_Asset
  Interface_Control_Document
  Interface_Requirements_Specification
  Meeting_Minutes
  Procurement_Specification
  Project_Memo
  Regulatory
  Risk_Mitigation_Plan
  Service_Level_Specification
  Software_Requirements_Specification
  Standard
  Statement_of_Work
  Strategy
  System_Requirements_Document
  System_Segment_Design_Document
  System_Segment_Specification
  Test__Evaluation_Master_Plan
  Test__Evaluation_Plan
  Test__Evaluation_Report
  Threat
  Trade_Study
}
# for mutations
input DocumentATTR_Input {
  documentDate: String
  nonGovernmentCategory: DocumentNonGovernmentCategory
  clin: String
  externalFilePath: String
  documentNumber: String
  title: String
  identification: String
  governmentCategory: DocumentGovernmentCategory
  revisionNumber: String
  cdrlNumber: String
  documentOverview: String
  documentScript: DocumentDocumentScript
  type: DocumentType
  scope: String
  description: String
}
type DocumentREL {
  """
  Impacted by identifies the entity that is affected by the risk.
  """
  impactedBy: [Document_ImpactedByTarget]

  """
  Referenced by identifies documents for which the subject document is an
  applicable or reference document.
  """
  referencedBy: [Document_ReferencedByTarget]

  """
  References identifies the applicable or reference document for the subject
  document. This relation is appropriate for documents that are generated from the
  contents of the database.
  """
  references: [Document_ReferencesTarget]

  """
  Refined by identifies the children of this entity.
  """
  refinedBy: [Document_RefinedByTarget]

  """
  Refines identifies the parent of this entity.
  """
  refines: [Document_RefinesTarget]

  """
  Reports on identifies the entities that form the basis for the documentation.
  """
  reportsOn: [Document_ReportsOnTarget]

  """
  Signed by identifies individuals who have signature authority for this document.
  """
  signedBy: [Document_SignedByTarget]

  """
  Traced from identifies a higher-level document from which the requirements in
  the subject document should be associated.
  """
  tracedFrom: [Document_TracedFromTarget]

  """
  Traces to identifies a lower-level document to which the requirements in the
  subject document should be associated.
  """
  tracesTo: [Document_TracesToTarget]

}
# for mutations
input DocumentREL_Input {
  impactedBy: [Document_ImpactedByTarget_Input]
  referencedBy: [Document_ReferencedByTarget_Input]
  references: [Document_ReferencesTarget_Input]
  refinedBy: [Document_RefinedByTarget_Input]
  refines: [Document_RefinesTarget_Input]
  reportsOn: [Document_ReportsOnTarget_Input]
  signedBy: [Document_SignedByTarget_Input]
  tracedFrom: [Document_TracedFromTarget_Input]
  tracesTo: [Document_TracesToTarget_Input]
}
type Document_ImpactedByTarget {
  riskTarget: RiskID
}
type Document_ReferencedByTarget {
  documentTarget: DocumentID
}
type Document_ReferencesTarget {
  documentTarget: DocumentID
}
type Document_RefinedByTarget {
  documentTarget: DocumentID
}
type Document_RefinesTarget {
  documentTarget: DocumentID
}
type Document_ReportsOnTarget {
  verificationRequirementTarget: VerificationRequirementID
  linkTarget: LinkID
}
type Document_SignedByTarget {
  organizationTarget: OrganizationID
  """
  Type indicates the kind of signature authority.
  """
  type: Document_SignedByType

}
enum Document_SignedByType {
  nil
  Approval
  Authentication
  Authorship
}
type Document_TracedFromTarget {
  documentTarget: DocumentID
}
type Document_TracesToTarget {
  documentTarget: DocumentID
}
# for mutations
input Document_ImpactedByTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Document_ReferencedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Document_ReferencesTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Document_RefinedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Document_RefinesTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Document_ReportsOnTarget_Input {
  operation: MutationOperation!
  verificationRequirementTarget: VerificationRequirementID_Input
  linkTarget: LinkID_Input
}
input Document_SignedByTarget_Input {
  operation: MutationOperation!
  organizationTarget: OrganizationID_Input
  type: Document_SignedByType
}
input Document_TracedFromTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Document_TracesToTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
#########################################
# Function definition
#########################################
type Function {
  identity: FunctionID!
  attributes: FunctionATTR
  parameters: [Parameter]
  relations: FunctionREL
}
# for mutations
input Function_Input {
  operation: MutationOperation!
  identity: FunctionID_Input!
  attributes: FunctionATTR_Input
  parameters: [Parameter_Input]
  relations: FunctionREL_Input
}
type FunctionID {
  id: ID!
  name: String!
  number: String!
}
# for mutations
input FunctionID_Input {
  id: ID # autogenerated on Create, required for Update / Delete
  name: String!
  number: String!
}
type FunctionATTR {
  """
  Doc. PUID is the project unique identifier that is often used in system
  development specifications and documents to identify the same entity in multiple
  documents. This is not to be confused with the database entity unique
  identifier.
  """
  puid: String

  """
  Duration is the time that this processing unit takes to complete.
  """
  duration: String

  """
  Execute Decomposition designates whether or not the decomposition of the entity
  should be included when performing a dynamic analysis.
  """
  executeDecomposition: Boolean

  """
  Log Message defines text to be placed in the simulation transcript upon
  execution of the unit.
  """
  logMessage: String

  """
  Timeout is a duration. If it is set, a processing unit that has been enabled but
  not started for that duration should terminate.
  """
  timeout: String

  """
  Title is the label to be used in formal documentation instead of the entity
  name.
  """
  title: String

  """
  Description is the written statement of this entity.
  """
  description: String

}
# for mutations
input FunctionATTR_Input {
  puid: String
  duration: String
  executeDecomposition: Boolean
  logMessage: String
  timeout: String
  title: String
  description: String
}
type FunctionREL {
  """
  Allocated to identifies the entity that implements this processing unit.
  """
  allocatedTo: [Function_AllocatedToTarget]

  """
  Based on identifies the needs that this entity fulfills in whole or in part.
  """
  basedOn: [Function_BasedOnTarget]

  """
  Causes identifies the technical or programmatic risk resulting from this entity.
  """
  causes: [Function_CausesTarget]

  """
  Decomposed by identifies the children of this entity.
  """
  decomposedBy: [Function_DecomposedByTarget]

  """
  Decomposes identifies the parent of this entity.
  """
  decomposes: [Function_DecomposesTarget]

  """
  Documented by identifies the source document which specifies and/or enhances the
  definition of this entity.
  """
  documentedBy: [Function_DocumentedByTarget]

  """
  Elaborates identifies the use case for which this entity provides the detailed
  behavioral model.
  """
  elaborates: [Function_ElaboratesTarget]

  """
  Impacted by identifies the entity that is affected by the risk.
  """
  impactedBy: [Function_ImpactedByTarget]

  """
  Inputs identifies the entities that are transformed by this processing unit.
  """
  inputs: [Function_InputsTarget]

  """
  Outputs identifies the products of the transformation carried out by this
  processing unit.
  """
  outputs: [Function_OutputsTarget]

  """
  Thread functions are reflected in a complex function in the integrated behavior
  model.
  """
  reflectedIn: [Function_ReflectedInTarget]

  """
  As the behavior model develops a complex function reflects one or more thread
  functions.
  """
  reflects: [Function_ReflectsTarget]

  """
  Services identifies the connection supported by this processing unit.
  """
  services: [Function_ServicesTarget]

  """
  Specified by identifies constraint and/or performance requirements that this
  entity must satisfy.
  """
  specifiedBy: [Function_SpecifiedByTarget]

  """
  Triggered by identifies the processing units that are enabled by this entity.  A
  processing unit begins execution when it has received control enablement, all of
  its triggers have arrived, and its necessary resources are available.
  """
  triggeredBy: [Function_TriggeredByTarget]

  """
  Verified by points to the method of requirement proof which specifies the
  verification technique, level, and status.
  """
  verifiedBy: [Function_VerifiedByTarget]

}
# for mutations
input FunctionREL_Input {
  allocatedTo: [Function_AllocatedToTarget_Input]
  basedOn: [Function_BasedOnTarget_Input]
  causes: [Function_CausesTarget_Input]
  decomposedBy: [Function_DecomposedByTarget_Input]
  decomposes: [Function_DecomposesTarget_Input]
  documentedBy: [Function_DocumentedByTarget_Input]
  elaborates: [Function_ElaboratesTarget_Input]
  impactedBy: [Function_ImpactedByTarget_Input]
  inputs: [Function_InputsTarget_Input]
  outputs: [Function_OutputsTarget_Input]
  reflectedIn: [Function_ReflectedInTarget_Input]
  reflects: [Function_ReflectsTarget_Input]
  services: [Function_ServicesTarget_Input]
  specifiedBy: [Function_SpecifiedByTarget_Input]
  triggeredBy: [Function_TriggeredByTarget_Input]
  verifiedBy: [Function_VerifiedByTarget_Input]
}
type Function_AllocatedToTarget {
  componentTarget: ComponentID
  """
  Behavior Type classifies the mapping of the processing unit to the
  implementation unit.
  """
  behaviorType: Function_AllocatedToBehaviorType

}
enum Function_AllocatedToBehaviorType {
  Atomic
  Integrated_Root
  Thread
}
type Function_BasedOnTarget {
  requirementTarget: RequirementID
}
type Function_CausesTarget {
  riskTarget: RiskID
}
type Function_DecomposedByTarget {
  functionTarget: FunctionID
}
type Function_DecomposesTarget {
  functionTarget: FunctionID
}
type Function_DocumentedByTarget {
  documentTarget: DocumentID
}
type Function_ElaboratesTarget {
  useCaseTarget: UseCaseID
  """
  Flow type indicates if this elaboration represents the primary flow or alternate
  flow.
  """
  flowType: Function_ElaboratesFlowType

}
enum Function_ElaboratesFlowType {
  Alternate
  Primary
}
type Function_ImpactedByTarget {
  riskTarget: RiskID
}
type Function_InputsTarget {
  itemTarget: ItemID
  """
  Queue Type specifies how the input entities should be ordered at the receiving
  unit.
  """
  queueType: Function_InputsQueueType

}
enum Function_InputsQueueType {
  FIFO
  LIFO
  Priority
  Reverse_Priority
}
type Function_OutputsTarget {
  itemTarget: ItemID
}
type Function_ReflectedInTarget {
  functionTarget: FunctionID
}
type Function_ReflectsTarget {
  functionTarget: FunctionID
}
type Function_ServicesTarget {
  linkTarget: LinkID
}
type Function_SpecifiedByTarget {
  requirementTarget: RequirementID
  """
  The Governs relationship attribute identifies the Parameter attribute that is
  associated in both the Requirement entity and Component entity joined by the
  specified by / specifies relationship.
  """
  governs: String

}
type Function_TriggeredByTarget {
  itemTarget: ItemID
  """
  Queue Type specifies how the triggering entities should queue up at the
  receiving processing unit.
  """
  queueType: Function_TriggeredByQueueType

}
enum Function_TriggeredByQueueType {
  FIFO
  LIFO
  Priority
  Reverse_Priority
}
type Function_VerifiedByTarget {
  verificationRequirementTarget: VerificationRequirementID
}
# for mutations
input Function_AllocatedToTarget_Input {
  operation: MutationOperation!
  componentTarget: ComponentID_Input
  behaviorType: Function_AllocatedToBehaviorType
}
input Function_BasedOnTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
}
input Function_CausesTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Function_DecomposedByTarget_Input {
  operation: MutationOperation!
  functionTarget: FunctionID_Input
}
input Function_DecomposesTarget_Input {
  operation: MutationOperation!
  functionTarget: FunctionID_Input
}
input Function_DocumentedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Function_ElaboratesTarget_Input {
  operation: MutationOperation!
  useCaseTarget: UseCaseID_Input
  flowType: Function_ElaboratesFlowType
}
input Function_ImpactedByTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Function_InputsTarget_Input {
  operation: MutationOperation!
  itemTarget: ItemID_Input
  queueType: Function_InputsQueueType
}
input Function_OutputsTarget_Input {
  operation: MutationOperation!
  itemTarget: ItemID_Input
}
input Function_ReflectedInTarget_Input {
  operation: MutationOperation!
  functionTarget: FunctionID_Input
}
input Function_ReflectsTarget_Input {
  operation: MutationOperation!
  functionTarget: FunctionID_Input
}
input Function_ServicesTarget_Input {
  operation: MutationOperation!
  linkTarget: LinkID_Input
}
input Function_SpecifiedByTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
  governs: String
}
input Function_TriggeredByTarget_Input {
  operation: MutationOperation!
  itemTarget: ItemID_Input
  queueType: Function_TriggeredByQueueType
}
input Function_VerifiedByTarget_Input {
  operation: MutationOperation!
  verificationRequirementTarget: VerificationRequirementID_Input
}
#########################################
# Item definition
#########################################
type Item {
  identity: ItemID!
  attributes: ItemATTR
  parameters: [Parameter]
  relations: ItemREL
}
# for mutations
input Item_Input {
  operation: MutationOperation!
  identity: ItemID_Input!
  attributes: ItemATTR_Input
  parameters: [Parameter_Input]
  relations: ItemREL_Input
}
type ItemID {
  id: ID!
  name: String!
  number: String!
}
# for mutations
input ItemID_Input {
  id: ID # autogenerated on Create, required for Update / Delete
  name: String!
  number: String!
}
type ItemATTR {
  """
  Range identifies the range of values that the entity can assume.
  """
  range: String

  """
  Units identifies the units of measurement for the value of the entity.
  """
  units: String

  """
  Accuracy identifies how correct the value of the entity must be.
  """
  accuracy: String

  """
  Fields identifies the data fields contained within the item.
  """
  fields: [String]

  """
  Precision identifies the number of significant digits required for the value of
  the entity.
  """
  precision: String

  """
  Doc. PUID is the project unique identifier that is often used in system
  development specifications and documents to identify the same entity in multiple
  documents. This is not to be confused with the database entity unique
  identifier.
  """
  puid: String

  """
  Size indicates the estimated size (in sizeUnits) of this entity.
  """
  size: String

  """
  Size Units indicates the measurement units associated with this entity.
  """
  sizeUnits: String

  """
  Priority is used to identify the order of processing of an entity. High priority
  entities (larger numbers) are processed before low priority entities (smaller
  numbers).
  """
  priority: String

  """
  Type is the physical type of this entity.
  """
  type: ItemType

  """
  Title is the label to be used in formal documentation instead of the entity
  name.
  """
  title: String

  """
  Description is the written statement of this entity.
  """
  description: String

}
enum ItemType {
  nil
  Analog
  Digital
  Physical
  Mixed
}
# for mutations
input ItemATTR_Input {
  range: String
  units: String
  accuracy: String
  fields: [String]
  precision: String
  puid: String
  size: String
  sizeUnits: String
  priority: String
  type: ItemType
  title: String
  description: String
}
type ItemREL {
  """
  Decomposed by identifies the children of this entity.
  """
  decomposedBy: [Item_DecomposedByTarget]

  """
  Decomposes identifies the parent of this entity.
  """
  decomposes: [Item_DecomposesTarget]

  """
  Documented by identifies the source document which specifies and/or enhances the
  definition of this entity.
  """
  documentedBy: [Item_DocumentedByTarget]

  """
  Impacted by identifies the entity that is affected by the risk.
  """
  impactedBy: [Item_ImpactedByTarget]

  """
  Input to identifies the processing unit that transforms this entity.
  """
  inputTo: [Item_InputToTarget]

  """
  Output from identifies the processing unit that produces this entity.
  """
  outputFrom: [Item_OutputFromTarget]

  """
  Specified by identifies constraint and/or performance requirements that this
  entity must satisfy.
  """
  specifiedBy: [Item_SpecifiedByTarget]

  """
  Transferred by identifies the connection over which this entity is transported.
  """
  transferredBy: [Item_TransferredByTarget]

  """
  Triggers identifies the information units that enable a processing unit to begin
  execution.  A processing unit begins execution when it has received control
  enablement, all of its triggers have arrived, and its necessary resources are
  available.
  """
  triggers: [Item_TriggersTarget]

  """
  Verified by points to the method of requirement proof which specifies the
  verification technique, level, and status.
  """
  verifiedBy: [Item_VerifiedByTarget]

}
# for mutations
input ItemREL_Input {
  decomposedBy: [Item_DecomposedByTarget_Input]
  decomposes: [Item_DecomposesTarget_Input]
  documentedBy: [Item_DocumentedByTarget_Input]
  impactedBy: [Item_ImpactedByTarget_Input]
  inputTo: [Item_InputToTarget_Input]
  outputFrom: [Item_OutputFromTarget_Input]
  specifiedBy: [Item_SpecifiedByTarget_Input]
  transferredBy: [Item_TransferredByTarget_Input]
  triggers: [Item_TriggersTarget_Input]
  verifiedBy: [Item_VerifiedByTarget_Input]
}
type Item_DecomposedByTarget {
  itemTarget: ItemID
}
type Item_DecomposesTarget {
  itemTarget: ItemID
}
type Item_DocumentedByTarget {
  documentTarget: DocumentID
}
type Item_ImpactedByTarget {
  riskTarget: RiskID
}
type Item_InputToTarget {
  functionTarget: FunctionID
  """
  Queue Type specifies how the input entities should be ordered at the receiving
  unit.
  """
  queueType: Item_InputToQueueType

}
enum Item_InputToQueueType {
  FIFO
  LIFO
  Priority
  Reverse_Priority
}
type Item_OutputFromTarget {
  functionTarget: FunctionID
}
type Item_SpecifiedByTarget {
  requirementTarget: RequirementID
  """
  The Governs relationship attribute identifies the Parameter attribute that is
  associated in both the Requirement entity and Component entity joined by the
  specified by / specifies relationship.
  """
  governs: String

}
type Item_TransferredByTarget {
  linkTarget: LinkID
}
type Item_TriggersTarget {
  functionTarget: FunctionID
  """
  Queue Type specifies how the triggering entities should queue up at the
  receiving processing unit.
  """
  queueType: Item_TriggersQueueType

}
enum Item_TriggersQueueType {
  FIFO
  LIFO
  Priority
  Reverse_Priority
}
type Item_VerifiedByTarget {
  verificationRequirementTarget: VerificationRequirementID
}
# for mutations
input Item_DecomposedByTarget_Input {
  operation: MutationOperation!
  itemTarget: ItemID_Input
}
input Item_DecomposesTarget_Input {
  operation: MutationOperation!
  itemTarget: ItemID_Input
}
input Item_DocumentedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Item_ImpactedByTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Item_InputToTarget_Input {
  operation: MutationOperation!
  functionTarget: FunctionID_Input
  queueType: Item_InputToQueueType
}
input Item_OutputFromTarget_Input {
  operation: MutationOperation!
  functionTarget: FunctionID_Input
}
input Item_SpecifiedByTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
  governs: String
}
input Item_TransferredByTarget_Input {
  operation: MutationOperation!
  linkTarget: LinkID_Input
}
input Item_TriggersTarget_Input {
  operation: MutationOperation!
  functionTarget: FunctionID_Input
  queueType: Item_TriggersQueueType
}
input Item_VerifiedByTarget_Input {
  operation: MutationOperation!
  verificationRequirementTarget: VerificationRequirementID_Input
}
#########################################
# Link definition
#########################################
type Link {
  identity: LinkID!
  attributes: LinkATTR
  parameters: [Parameter]
  relations: LinkREL
}
# for mutations
input Link_Input {
  operation: MutationOperation!
  identity: LinkID_Input!
  attributes: LinkATTR_Input
  parameters: [Parameter_Input]
  relations: LinkREL_Input
}
type LinkID {
  id: ID!
  name: String!
  number: String!
}
# for mutations
input LinkID_Input {
  id: ID # autogenerated on Create, required for Update / Delete
  name: String!
  number: String!
}
type LinkATTR {
  """
  Protocol identifies the communication protocol for this entity.
  """
  protocol: String

  """
  Type is the physical category of this entity.
  """
  type: LinkType

  """
  Delay represents the time delay that occurs when an information unit traverses
  this connecting unit. It is intended to model the actual propagation delay and
  processing delay, not the delay due to resource utilization.
  """
  delay: String

  """
  Capacity indicates the flow capacity (in capacityUnits) of this connecting
  entity.
  """
  capacity: String

  """
  Title is the label to be used in formal documentation instead of the entity
  name.
  """
  title: String

  """
  Doc. PUID is the project unique identifier that is often used in system
  development specifications and documents to identify the same entity in multiple
  documents. This is not to be confused with the database entity unique
  identifier.
  """
  puid: String

  """
  Delay Units identifies the units for the delay for this connecting unit.
  """
  delayUnits: String

  """
  Capacity Units indicates the measurement units associated with this connecting
  entity.
  """
  capacityUnits: String

  """
  Description is the written statement of this entity.
  """
  description: String

}
enum LinkType {
  nil
  Data
  Fluid
  Electrical
  Human
  Mechanical
  Structural
  Thermal
}
# for mutations
input LinkATTR_Input {
  protocol: String
  type: LinkType
  delay: String
  capacity: String
  title: String
  puid: String
  delayUnits: String
  capacityUnits: String
  description: String
}
type LinkREL {
  """
  Assigned to identifies a source entity being overseen or controlled by the
  target entity.
  """
  assignedTo: [Link_AssignedToTarget]

  """
  Causes identifies the technical or programmatic risk resulting from this entity.
  """
  causes: [Link_CausesTarget]

  """
  Connects to identifies the connection that serves to link this entity to another
  entity.
  """
  connectsTo: [Link_ConnectsToTarget]

  """
  Documented by identifies the source document which specifies and/or enhances the
  definition of this entity.
  """
  documentedBy: [Link_DocumentedByTarget]

  """
  Impacted by identifies the entity that is affected by the risk.
  """
  impactedBy: [Link_ImpactedByTarget]

  """
  Included in identifies the parent of this entity.
  """
  includedIn: [Link_IncludedInTarget]

  """
  Includes identifies the children of this entity.
  """
  includes: [Link_IncludesTarget]

  """
  Reported by identifies the documentation entity of which the entity is the
  primary subject.
  """
  reportedBy: [Link_ReportedByTarget]

  """
  Serviced by identifies the processing unit that performs the interface function.
  """
  servicedBy: [Link_ServicedByTarget]

  """
  Specified by identifies constraint and/or performance requirements that this
  entity must satisfy.
  """
  specifiedBy: [Link_SpecifiedByTarget]

  """
  Transfers identifies the information that this connecting unit passes between
  implementation units.
  """
  transfers: [Link_TransfersTarget]

  """
  Verified by points to the method of requirement proof which specifies the
  verification technique, level, and status.
  """
  verifiedBy: [Link_VerifiedByTarget]

}
# for mutations
input LinkREL_Input {
  assignedTo: [Link_AssignedToTarget_Input]
  causes: [Link_CausesTarget_Input]
  connectsTo: [Link_ConnectsToTarget_Input]
  documentedBy: [Link_DocumentedByTarget_Input]
  impactedBy: [Link_ImpactedByTarget_Input]
  includedIn: [Link_IncludedInTarget_Input]
  includes: [Link_IncludesTarget_Input]
  reportedBy: [Link_ReportedByTarget_Input]
  servicedBy: [Link_ServicedByTarget_Input]
  specifiedBy: [Link_SpecifiedByTarget_Input]
  transfers: [Link_TransfersTarget_Input]
  verifiedBy: [Link_VerifiedByTarget_Input]
}
type Link_AssignedToTarget {
  organizationTarget: OrganizationID
}
type Link_CausesTarget {
  riskTarget: RiskID
}
type Link_ConnectsToTarget {
  componentTarget: ComponentID
  """
  Port ID provides a unique identification for the port that is used between the
  Link and the Component.
  """
  portID: String

}
type Link_DocumentedByTarget {
  documentTarget: DocumentID
}
type Link_ImpactedByTarget {
  riskTarget: RiskID
}
type Link_IncludedInTarget {
  linkTarget: LinkID
}
type Link_IncludesTarget {
  linkTarget: LinkID
}
type Link_ReportedByTarget {
  documentTarget: DocumentID
}
type Link_ServicedByTarget {
  functionTarget: FunctionID
}
type Link_SpecifiedByTarget {
  requirementTarget: RequirementID
  """
  The Governs relationship attribute identifies the Parameter attribute that is
  associated in both the Requirement entity and Component entity joined by the
  specified by / specifies relationship.
  """
  governs: String

}
type Link_TransfersTarget {
  itemTarget: ItemID
}
type Link_VerifiedByTarget {
  verificationRequirementTarget: VerificationRequirementID
}
# for mutations
input Link_AssignedToTarget_Input {
  operation: MutationOperation!
  organizationTarget: OrganizationID_Input
}
input Link_CausesTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Link_ConnectsToTarget_Input {
  operation: MutationOperation!
  componentTarget: ComponentID_Input
  portID: String
}
input Link_DocumentedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Link_ImpactedByTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Link_IncludedInTarget_Input {
  operation: MutationOperation!
  linkTarget: LinkID_Input
}
input Link_IncludesTarget_Input {
  operation: MutationOperation!
  linkTarget: LinkID_Input
}
input Link_ReportedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Link_ServicedByTarget_Input {
  operation: MutationOperation!
  functionTarget: FunctionID_Input
}
input Link_SpecifiedByTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
  governs: String
}
input Link_TransfersTarget_Input {
  operation: MutationOperation!
  itemTarget: ItemID_Input
}
input Link_VerifiedByTarget_Input {
  operation: MutationOperation!
  verificationRequirementTarget: VerificationRequirementID_Input
}
#########################################
# Organization definition
#########################################
type Organization {
  identity: OrganizationID!
  attributes: OrganizationATTR
  parameters: [Parameter]
  relations: OrganizationREL
}
# for mutations
input Organization_Input {
  operation: MutationOperation!
  identity: OrganizationID_Input!
  attributes: OrganizationATTR_Input
  parameters: [Parameter_Input]
  relations: OrganizationREL_Input
}
type OrganizationID {
  id: ID!
  name: String!
  number: String!
}
# for mutations
input OrganizationID_Input {
  id: ID # autogenerated on Create, required for Update / Delete
  name: String!
  number: String!
}
type OrganizationATTR {
  """
  Role identifies the manner of participation in the project of the individual or
  organization.
  """
  role: String

  """
  Title is the title of an individual.
  """
  title: String

  """
  Abbreviation is a shorted name for the entity.
  """
  abbreviation: String

  """
  Description is the written statement of this entity.
  """
  description: String

}
# for mutations
input OrganizationATTR_Input {
  role: String
  title: String
  abbreviation: String
  description: String
}
type OrganizationREL {
  """
  Causes identifies the technical or programmatic risk resulting from this entity.
  """
  causes: [Organization_CausesTarget]

  """
  Documented by identifies the source document which specifies and/or enhances the
  definition of this entity.
  """
  documentedBy: [Organization_DocumentedByTarget]

  """
  Impacted by identifies the entity that is affected by the risk.
  """
  impactedBy: [Organization_ImpactedByTarget]

  """
  Included in identifies the parent of this entity.
  """
  includedIn: [Organization_IncludedInTarget]

  """
  Includes identifies the children of this entity.
  """
  includes: [Organization_IncludesTarget]

  """
  Responsible for identifies the target entities overseen or controlled by the
  source entity.
  """
  responsibleFor: [Organization_ResponsibleForTarget]

  """
  Signs identifies documents over which this element has signature authority.
  """
  signs: [Organization_SignsTarget]

}
# for mutations
input OrganizationREL_Input {
  causes: [Organization_CausesTarget_Input]
  documentedBy: [Organization_DocumentedByTarget_Input]
  impactedBy: [Organization_ImpactedByTarget_Input]
  includedIn: [Organization_IncludedInTarget_Input]
  includes: [Organization_IncludesTarget_Input]
  responsibleFor: [Organization_ResponsibleForTarget_Input]
  signs: [Organization_SignsTarget_Input]
}
type Organization_CausesTarget {
  riskTarget: RiskID
}
type Organization_DocumentedByTarget {
  documentTarget: DocumentID
}
type Organization_ImpactedByTarget {
  riskTarget: RiskID
}
type Organization_IncludedInTarget {
  organizationTarget: OrganizationID
}
type Organization_IncludesTarget {
  organizationTarget: OrganizationID
}
type Organization_ResponsibleForTarget {
  riskTarget: RiskID
  linkTarget: LinkID
}
type Organization_SignsTarget {
  documentTarget: DocumentID
  """
  Type indicates the kind of signature authority.
  """
  type: Organization_SignsType

}
enum Organization_SignsType {
  nil
  Approval
  Authentication
  Authorship
}
# for mutations
input Organization_CausesTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Organization_DocumentedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Organization_ImpactedByTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Organization_IncludedInTarget_Input {
  operation: MutationOperation!
  organizationTarget: OrganizationID_Input
}
input Organization_IncludesTarget_Input {
  operation: MutationOperation!
  organizationTarget: OrganizationID_Input
}
input Organization_ResponsibleForTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
  linkTarget: LinkID_Input
}
input Organization_SignsTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
  type: Organization_SignsType
}
#########################################
# Requirement definition
#########################################
type Requirement {
  identity: RequirementID!
  attributes: RequirementATTR
  parameters: [Parameter]
  relations: RequirementREL
}
# for mutations
input Requirement_Input {
  operation: MutationOperation!
  identity: RequirementID_Input!
  attributes: RequirementATTR_Input
  parameters: [Parameter_Input]
  relations: RequirementREL_Input
}
type RequirementID {
  id: ID!
  name: String!
  number: String!
}
# for mutations
input RequirementID_Input {
  id: ID # autogenerated on Create, required for Update / Delete
  name: String!
  number: String!
}
type RequirementATTR {
  """
  Weight Factor indicates the relative importance of a particular originating
  requirement.
  """
  weightFactor: Float

  """
  Title is the label to be used in formal documentation instead of the element
  name.
  """
  title: String

  """
  Type is the nature of the requirement. A requirement of type Capability ought to
  be the only the basis of an OperationalActivity.
  """
  type: RequirementType

  """
  Rationale documents the reason for the requirement.
  """
  rationale: String

  """
  Incentive Performance Parameter identifies whether or not this is a requirement
  affecting contract award fee.
  """
  incentivePerformanceParameter: Boolean

  """
  Key Performance Parameter identifies whether or not this is a key performance
  parameter.
  """
  keyPerformanceParameter: Boolean

  """
  Value of the constraint or performance measure.
  """
  value: String

  """
  Paragraph Number is the number of the source paragraph from which this
  originating requirement was extracted.
  """
  paragraphNumber: String

  """
  Paragraph Title is the title of the source paragraph from which this originating
  requirement was extracted.
  """
  paragraphTitle: String

  """
  Doc. PUID is the project unique identifier that is often used in system
  development specifications and documents to identify the same entity in multiple
  documents. This is not to be confused with the database entity unique
  identifier.
  """
  puid: String

  """
  Origin differentiates between originating requirements, derived requirements,
  and design decisions.
  """
  origin: RequirementOrigin

  """
  A Key Performance Parameter (KPP) is a system metric that is considered critical
  or essential to the development of an effective capability. KPPs are generally
  controlled by the customer or stakeholder. Failure to meet the KPP can be cause
  for a concept or system to be reevaluated as not meeting stakeholder minimum
  requirements.    A Key System Attribute (KSA) is an attribute or characteristic
  considered most critical or essential in meeting a specific capability but is
  not selected as a KPP. KSAs provide an additional level of prioritization below
  KPP but with lower level control than the stakeholder level.    A Measure of
  Operational Effectiveness (MOE) is an operational measure of success for an
  architecture or system which is closely related to the achievement of the
  mission or operational objective being evaluated in the intended operational
  environment under a specified set of conditions. MOEs address the question of
  how well the solution achieves the intended purpose.    A Measure of Performance
  Effectiveness (MOP) is a measure that characterizes physical or functional
  attributes related to a specific solution or system operation, as measured under
  specified testing and/or operational conditions.
  """
  performanceParameterType: RequirementPerformanceParameterType

  """
  Units of the constraining condition or performance measure.
  """
  units: String

  """
  Description is the written statement of this entity.
  """
  description: String

}
enum RequirementType {
  nil
  Composite
  Constraint
  Functional
  Incentive_Award_Fee_Criterion
  Performance
  Programmatic
  Test
  Verification
}
enum RequirementOrigin {
  nil
  Derived
  Design_Decision
  Originating
}
enum RequirementPerformanceParameterType {
  nil
  KPP
  KSA
  MOE
  MOP
}
# for mutations
input RequirementATTR_Input {
  weightFactor: Float
  title: String
  type: RequirementType
  rationale: String
  incentivePerformanceParameter: Boolean
  keyPerformanceParameter: Boolean
  value: String
  paragraphNumber: String
  paragraphTitle: String
  puid: String
  origin: RequirementOrigin
  performanceParameterType: RequirementPerformanceParameterType
  units: String
  description: String
}
type RequirementREL {
  """
  Basis of identifies the entities that fulfill one or more needs.
  """
  basisOf: [Requirement_BasisOfTarget]

  """
  Causes identifies the technical or programmatic risk resulting from this entity.
  """
  causes: [Requirement_CausesTarget]

  """
  Documented by identifies the source document which specifies and/or enhances the
  definition of this entity.
  """
  documentedBy: [Requirement_DocumentedByTarget]

  """
  A requirement may be elicited by a Use Case.
  """
  elicitedBy: [Requirement_ElicitedByTarget]

  """
  Impacted by identifies the entity that is affected by the risk.
  """
  impactedBy: [Requirement_ImpactedByTarget]

  """
  Refined by identifies the children of this entity.
  """
  refinedBy: [Requirement_RefinedByTarget]

  """
  Refines identifies the parent of this entity.
  """
  refines: [Requirement_RefinesTarget]

  """
  Specifies identifies those entities whose performance or whose characteristics
  are bounded by the requirement.
  """
  specifies: [Requirement_SpecifiesTarget]

  """
  Verified by points to the method of requirement proof which specifies the
  verification technique, level, and status.
  """
  verifiedBy: [Requirement_VerifiedByTarget]

}
# for mutations
input RequirementREL_Input {
  basisOf: [Requirement_BasisOfTarget_Input]
  causes: [Requirement_CausesTarget_Input]
  documentedBy: [Requirement_DocumentedByTarget_Input]
  elicitedBy: [Requirement_ElicitedByTarget_Input]
  impactedBy: [Requirement_ImpactedByTarget_Input]
  refinedBy: [Requirement_RefinedByTarget_Input]
  refines: [Requirement_RefinesTarget_Input]
  specifies: [Requirement_SpecifiesTarget_Input]
  verifiedBy: [Requirement_VerifiedByTarget_Input]
}
type Requirement_BasisOfTarget {
  useCaseTarget: UseCaseID
  functionTarget: FunctionID
  verificationRequirementTarget: VerificationRequirementID
}
type Requirement_CausesTarget {
  riskTarget: RiskID
}
type Requirement_DocumentedByTarget {
  documentTarget: DocumentID
}
type Requirement_ElicitedByTarget {
  useCaseTarget: UseCaseID
}
type Requirement_ImpactedByTarget {
  riskTarget: RiskID
}
type Requirement_RefinedByTarget {
  requirementTarget: RequirementID
}
type Requirement_RefinesTarget {
  requirementTarget: RequirementID
}
type Requirement_SpecifiesTarget {
  itemTarget: ItemID
  functionTarget: FunctionID
  """
  The Governs relationship attribute identifies the Parameter attribute that is
  associated in both the Requirement entity and Component entity joined by the
  specified by / specifies relationship.
  """
  governs: String

}
type Requirement_VerifiedByTarget {
  verificationRequirementTarget: VerificationRequirementID
}
# for mutations
input Requirement_BasisOfTarget_Input {
  operation: MutationOperation!
  useCaseTarget: UseCaseID_Input
  functionTarget: FunctionID_Input
  verificationRequirementTarget: VerificationRequirementID_Input
}
input Requirement_CausesTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Requirement_DocumentedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Requirement_ElicitedByTarget_Input {
  operation: MutationOperation!
  useCaseTarget: UseCaseID_Input
}
input Requirement_ImpactedByTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Requirement_RefinedByTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
}
input Requirement_RefinesTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
}
input Requirement_SpecifiesTarget_Input {
  operation: MutationOperation!
  itemTarget: ItemID_Input
  functionTarget: FunctionID_Input
  governs: String
}
input Requirement_VerifiedByTarget_Input {
  operation: MutationOperation!
  verificationRequirementTarget: VerificationRequirementID_Input
}
#########################################
# Risk definition
#########################################
type Risk {
  identity: RiskID!
  attributes: RiskATTR
  parameters: [Parameter]
  relations: RiskREL
}
# for mutations
input Risk_Input {
  operation: MutationOperation!
  identity: RiskID_Input!
  attributes: RiskATTR_Input
  parameters: [Parameter_Input]
  relations: RiskREL_Input
}
type RiskID {
  id: ID!
  name: String!
  number: String!
}
# for mutations
input RiskID_Input {
  id: ID # autogenerated on Create, required for Update / Delete
  name: String!
  number: String!
}
type RiskATTR {
  """
  Risk score is the product of the likelihood and the consequence. To have this
  automatically calculated, run the Utility script Calculate Risk Score.
  """
  riskScore: Int

  """
  Risk Rating is determined by the combination of Consequence and Likelihood in
  accordance with the standard risk cube. To have this automatically populated
  based on the settings for Consequence and Likelihood run the Utility script Set
  Risk Rating.
  """
  riskRating: RiskRiskRating

  """
  Likelihood is the probability of occurrence.
  """
  likelihood: RiskLikelihood

  """
  Trigger date is when it is expected that the risk event will occur at which time
  the risk will either occur (and become an issue) or not occur and be retired.
  """
  triggerDate: String

  """
  Handling approach is the means to respond to the risk.
  """
  handlingApproach: RiskHandlingApproach

  """
  Consequence is the severity of adverse effects stemming from the referenced
  cause.   1 Minimal or no consequence to technical performance.   2 Minor
  reduction in technical performance or supportability, can be tolerated with
  little or no impact on program.   3 Moderate reduction in technical performance
  or supportability with limited impact on program objectives.   4 Significant
  degradation in technical performance or major shortfall in supportability; may
  jeopardize program success.   5 Severe degradation in technical performance;
  cannot meet KPP or key technical/supportability threshold; will jeopardize
  program success.
  """
  consequence: RiskConsequence

  """
  Status documents the current state of risk management.
  """
  status: RiskStatus

  """
  Type identifies the nature of this risk.
  """
  type: RiskType

  """
  Significance is the potential adverse outcomes associated with the unmitigated
  risk.
  """
  significance: String

  """
  Scoring rationale documents the logic and thinking behind how the scores for
  likelihood and consequence were determined.
  """
  scoringRationale: String

  """
  Description is the written statement of this entity.
  """
  description: String

}
enum RiskRiskRating {
  nil
  Low
  Medium
  High
}
enum RiskLikelihood {
  nil
  E_1__Not_Likely
  E_2__Low_Likelihood
  E_3__Likely
  E_4__High_Likelihood
  E_5__Near_Certainty
}
enum RiskHandlingApproach {
  nil
  Accept
  Avoid
  Mitigate
  Transfer
}
enum RiskConsequence {
  nil
  E_1__Minimal
  E_2__Minor
  E_3__Moderate
  E_4__Significant
  E_5__Severe
}
enum RiskStatus {
  Proposed
  Active
  Realized
  Retired
  Rejected
}
enum RiskType {
  nil
  Cost
  Programmatic
  Schedule
  Technical
}
# for mutations
input RiskATTR_Input {
  riskScore: Int
  riskRating: RiskRiskRating
  likelihood: RiskLikelihood
  triggerDate: String
  handlingApproach: RiskHandlingApproach
  consequence: RiskConsequence
  status: RiskStatus
  type: RiskType
  significance: String
  scoringRationale: String
  description: String
}
type RiskREL {
  """
  Assigned to identifies a source entity being overseen or controlled by the
  target entity.
  """
  assignedTo: [Risk_AssignedToTarget]

  """
  Caused by identifies the entity in the design which precipitates this risk. For
  instance, a newly conceived component may cause a program schedule
  (programmatic) risk.
  """
  causedBy: [Risk_CausedByTarget]

  """
  Comes from identifies a problem at a lower-level in the system hierarchy
  resulting in this higher-level problem.
  """
  comesFrom: [Risk_ComesFromTarget]

  """
  Documented by identifies the source document which specifies and/or enhances the
  definition of this entity.
  """
  documentedBy: [Risk_DocumentedByTarget]

  """
  Impacts identifies the risk that threatens the successful definition or
  implementation of the entity.
  """
  impacts: [Risk_ImpactsTarget]

  """
  Leads to identifies the higher-level problem (in terms of the system hierarchy)
  that results from this problem.
  """
  leadsTo: [Risk_LeadsToTarget]

}
# for mutations
input RiskREL_Input {
  assignedTo: [Risk_AssignedToTarget_Input]
  causedBy: [Risk_CausedByTarget_Input]
  comesFrom: [Risk_ComesFromTarget_Input]
  documentedBy: [Risk_DocumentedByTarget_Input]
  impacts: [Risk_ImpactsTarget_Input]
  leadsTo: [Risk_LeadsToTarget_Input]
}
type Risk_AssignedToTarget {
  organizationTarget: OrganizationID
}
type Risk_CausedByTarget {
  componentTarget: ComponentID
  organizationTarget: OrganizationID
  linkTarget: LinkID
  verificationRequirementTarget: VerificationRequirementID
  functionTarget: FunctionID
  requirementTarget: RequirementID
  useCaseTarget: UseCaseID
}
type Risk_ComesFromTarget {
  riskTarget: RiskID
}
type Risk_DocumentedByTarget {
  documentTarget: DocumentID
}
type Risk_ImpactsTarget {
  requirementTarget: RequirementID
  useCaseTarget: UseCaseID
  organizationTarget: OrganizationID
  documentTarget: DocumentID
}
type Risk_LeadsToTarget {
  riskTarget: RiskID
}
# for mutations
input Risk_AssignedToTarget_Input {
  operation: MutationOperation!
  organizationTarget: OrganizationID_Input
}
input Risk_CausedByTarget_Input {
  operation: MutationOperation!
  componentTarget: ComponentID_Input
  organizationTarget: OrganizationID_Input
  linkTarget: LinkID_Input
  verificationRequirementTarget: VerificationRequirementID_Input
  functionTarget: FunctionID_Input
  requirementTarget: RequirementID_Input
  useCaseTarget: UseCaseID_Input
}
input Risk_ComesFromTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input Risk_DocumentedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input Risk_ImpactsTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
  useCaseTarget: UseCaseID_Input
  organizationTarget: OrganizationID_Input
  documentTarget: DocumentID_Input
}
input Risk_LeadsToTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
#########################################
# UseCase definition
#########################################
type UseCase {
  identity: UseCaseID!
  attributes: UseCaseATTR
  parameters: [Parameter]
  relations: UseCaseREL
}
# for mutations
input UseCase_Input {
  operation: MutationOperation!
  identity: UseCaseID_Input!
  attributes: UseCaseATTR_Input
  parameters: [Parameter_Input]
  relations: UseCaseREL_Input
}
type UseCaseID {
  id: ID!
  name: String!
  number: String!
}
# for mutations
input UseCaseID_Input {
  id: ID # autogenerated on Create, required for Update / Delete
  name: String!
  number: String!
}
type UseCaseATTR {
  """
  Doc. PUID is the project unique identifier that is often used in system
  development specifications and documents to identify the same entity in multiple
  documents. This is not to be confused with the database entity unique
  identifier.
  """
  puid: String

  """
  Preconditions are the conditions that must hold true for this use case to begin.
  """
  preconditions: String

  """
  Primary flow is a textual description of the most frequent scenario or scenarios
  for this use case. The primary flow serves as the foundation for the behavioral
  representation of the use case.
  """
  primaryFlow: String

  """
  Alternate flow is a textual description of the scenarios that are less frequent
  or exceptions. The alternate flow serves helps guide the development of the
  integrated logic.
  """
  alternateFlow: String

  """
  Postconditions are the conditions that must hold true once this case has
  completed.
  """
  postconditions: String

  """
  Description is the written statement of this entity.
  """
  description: String

}
# for mutations
input UseCaseATTR_Input {
  puid: String
  preconditions: String
  primaryFlow: String
  alternateFlow: String
  postconditions: String
  description: String
}
type UseCaseREL {
  """
  Based on identifies the needs that this entity fulfills in whole or in part.
  """
  basedOn: [UseCase_BasedOnTarget]

  """
  Causes identifies the technical or programmatic risk resulting from this entity.
  """
  causes: [UseCase_CausesTarget]

  """
  Documented by identifies the source document which specifies and/or enhances the
  definition of this entity.
  """
  documentedBy: [UseCase_DocumentedByTarget]

  """
  A Use Case enables the elicitation of requirements from stakeholders.
  """
  elicits: [UseCase_ElicitsTarget]

  """
  Extended by identifies the use cases which extend the entity by providing
  additional fragments of functionality not considered part of the normal base use
  case.
  """
  extendedBy: [UseCase_ExtendedByTarget]

  """
  Extends identifies the use case for which this entity provides an additional
  fragment of functionality not considered part of the normal base use case.
  """
  extends: [UseCase_ExtendsTarget]

  """
  Generalization of associates a specific object classification with a more
  general object classification. For example, "Vehicle" is a generalization of
  "Car," "Train," and "Plane."
  """
  generalizationOf: [UseCase_GeneralizationOfTarget]

  """
  Impacted by identifies the entity that is affected by the risk.
  """
  impactedBy: [UseCase_ImpactedByTarget]

  """
  Included in identifies the parent of this entity.
  """
  includedIn: [UseCase_IncludedInTarget]

  """
  Includes identifies the children of this entity.
  """
  includes: [UseCase_IncludesTarget]

  """
  Kind of indicates classification. This relationship is often referred to as the
  "is a" relationship (i.e., a car "is a" vehicle).
  """
  kindOf: [UseCase_KindOfTarget]

}
# for mutations
input UseCaseREL_Input {
  basedOn: [UseCase_BasedOnTarget_Input]
  causes: [UseCase_CausesTarget_Input]
  documentedBy: [UseCase_DocumentedByTarget_Input]
  elicits: [UseCase_ElicitsTarget_Input]
  extendedBy: [UseCase_ExtendedByTarget_Input]
  extends: [UseCase_ExtendsTarget_Input]
  generalizationOf: [UseCase_GeneralizationOfTarget_Input]
  impactedBy: [UseCase_ImpactedByTarget_Input]
  includedIn: [UseCase_IncludedInTarget_Input]
  includes: [UseCase_IncludesTarget_Input]
  kindOf: [UseCase_KindOfTarget_Input]
}
type UseCase_BasedOnTarget {
  requirementTarget: RequirementID
}
type UseCase_CausesTarget {
  riskTarget: RiskID
}
type UseCase_DocumentedByTarget {
  documentTarget: DocumentID
}
type UseCase_ElicitsTarget {
  requirementTarget: RequirementID
}
type UseCase_ExtendedByTarget {
  useCaseTarget: UseCaseID
  """
  Extension point is the point at which the extending use case extends the base
  use case functionality.
  """
  extensionPoint: String

}
type UseCase_ExtendsTarget {
  useCaseTarget: UseCaseID
  """
  Extension point is the point at which the extending use case extends the base
  use case functionality.
  """
  extensionPoint: String

}
type UseCase_GeneralizationOfTarget {
  useCaseTarget: UseCaseID
  """
  Type classifies the nature of the generalization / specialization relationship.
  Inheritance indicates that the specialization shares the properties of the
  generalization. Instance indicates that the specialization also shares the
  relationships of the generalization.
  """
  type: UseCase_GeneralizationOfType

}
enum UseCase_GeneralizationOfType {
  Inheritance
  Instance
}
type UseCase_ImpactedByTarget {
  riskTarget: RiskID
}
type UseCase_IncludedInTarget {
  useCaseTarget: UseCaseID
}
type UseCase_IncludesTarget {
  useCaseTarget: UseCaseID
}
type UseCase_KindOfTarget {
  useCaseTarget: UseCaseID
  """
  Type classifies the nature of the generalization / specialization relationship.
  Inheritance indicates that the specialization shares the properties of the
  generalization. Instance indicates that the specialization also shares the
  relationships of the generalization.
  """
  type: UseCase_KindOfType

}
enum UseCase_KindOfType {
  Inheritance
  Instance
}
# for mutations
input UseCase_BasedOnTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
}
input UseCase_CausesTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input UseCase_DocumentedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input UseCase_ElicitsTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
}
input UseCase_ExtendedByTarget_Input {
  operation: MutationOperation!
  useCaseTarget: UseCaseID_Input
  extensionPoint: String
}
input UseCase_ExtendsTarget_Input {
  operation: MutationOperation!
  useCaseTarget: UseCaseID_Input
  extensionPoint: String
}
input UseCase_GeneralizationOfTarget_Input {
  operation: MutationOperation!
  useCaseTarget: UseCaseID_Input
  type: UseCase_GeneralizationOfType
}
input UseCase_ImpactedByTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input UseCase_IncludedInTarget_Input {
  operation: MutationOperation!
  useCaseTarget: UseCaseID_Input
}
input UseCase_IncludesTarget_Input {
  operation: MutationOperation!
  useCaseTarget: UseCaseID_Input
}
input UseCase_KindOfTarget_Input {
  operation: MutationOperation!
  useCaseTarget: UseCaseID_Input
  type: UseCase_KindOfType
}
#########################################
# VerificationRequirement definition
#########################################
type VerificationRequirement {
  identity: VerificationRequirementID!
  attributes: VerificationRequirementATTR
  parameters: [Parameter]
  relations: VerificationRequirementREL
}
# for mutations
input VerificationRequirement_Input {
  operation: MutationOperation!
  identity: VerificationRequirementID_Input!
  attributes: VerificationRequirementATTR_Input
  parameters: [Parameter_Input]
  relations: VerificationRequirementREL_Input
}
type VerificationRequirementID {
  id: ID!
  name: String!
  number: String!
}
# for mutations
input VerificationRequirementID_Input {
  id: ID # autogenerated on Create, required for Update / Delete
  name: String!
  number: String!
}
type VerificationRequirementATTR {
  """
  Type is the nature of the verification requirement, specifically whether it is a
  verification or validation requirement.
  """
  type: VerificationRequirementType

  """
  Title is the label to be used in formal documentation instead of the element
  name.
  """
  title: String

  """
  Doc. PUID is the project unique identifier that is often used in system
  development specifications and documents to identify the same entity in multiple
  documents. This is not to be confused with the database entity unique
  identifier.
  """
  puid: String

  """
  Status identifies the current status of the verification activity.
  """
  status: VerificationRequirementStatus

  """
  Level identifies the development level at which the related requirement
  statements are to be verified.
  """
  level: VerificationRequirementLevel

  """
  Method characterizes the qualification techniques to be used to ensure that the
  related requirement statements are satisfied.
  """
  method: VerificationRequirementMethod

  """
  Description is the written statement of this entity.
  """
  description: String

}
enum VerificationRequirementType {
  nil
  Validation
  Verification
}
enum VerificationRequirementStatus {
  nil
  Not_Yet_Planned
  Planned
  In_Progress
  Completed__Satisfactory
  Completed__Unsatisfactory
}
enum VerificationRequirementLevel {
  nil
  System
  Segment
  Subsystem
  HWCI
  HW_Element
  Part
  CSCI
  CSC
  CSU
  Facility
  Task
}
enum VerificationRequirementMethod {
  nil
  Analysis
  Demonstration
  Inspection
  Test
}
# for mutations
input VerificationRequirementATTR_Input {
  type: VerificationRequirementType
  title: String
  puid: String
  status: VerificationRequirementStatus
  level: VerificationRequirementLevel
  method: VerificationRequirementMethod
  description: String
}
type VerificationRequirementREL {
  """
  Based on identifies the needs that this entity fulfills in whole or in part.
  """
  basedOn: [VerificationRequirement_BasedOnTarget]

  """
  Causes identifies the technical or programmatic risk resulting from this entity.
  """
  causes: [VerificationRequirement_CausesTarget]

  """
  Documented by identifies the source document which specifies and/or enhances the
  definition of this entity.
  """
  documentedBy: [VerificationRequirement_DocumentedByTarget]

  """
  Impacted by identifies the entity that is affected by the risk.
  """
  impactedBy: [VerificationRequirement_ImpactedByTarget]

  """
  Reported by identifies the documentation entity of which the entity is the
  primary subject.
  """
  reportedBy: [VerificationRequirement_ReportedByTarget]

  """
  Verifies identifies the entities to be validated.
  """
  verifies: [VerificationRequirement_VerifiesTarget]

}
# for mutations
input VerificationRequirementREL_Input {
  basedOn: [VerificationRequirement_BasedOnTarget_Input]
  causes: [VerificationRequirement_CausesTarget_Input]
  documentedBy: [VerificationRequirement_DocumentedByTarget_Input]
  impactedBy: [VerificationRequirement_ImpactedByTarget_Input]
  reportedBy: [VerificationRequirement_ReportedByTarget_Input]
  verifies: [VerificationRequirement_VerifiesTarget_Input]
}
type VerificationRequirement_BasedOnTarget {
  requirementTarget: RequirementID
}
type VerificationRequirement_CausesTarget {
  riskTarget: RiskID
}
type VerificationRequirement_DocumentedByTarget {
  documentTarget: DocumentID
}
type VerificationRequirement_ImpactedByTarget {
  riskTarget: RiskID
}
type VerificationRequirement_ReportedByTarget {
  documentTarget: DocumentID
}
type VerificationRequirement_VerifiesTarget {
  requirementTarget: RequirementID
  functionTarget: FunctionID
  itemTarget: ItemID
  componentTarget: ComponentID
  linkTarget: LinkID
}
# for mutations
input VerificationRequirement_BasedOnTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
}
input VerificationRequirement_CausesTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input VerificationRequirement_DocumentedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input VerificationRequirement_ImpactedByTarget_Input {
  operation: MutationOperation!
  riskTarget: RiskID_Input
}
input VerificationRequirement_ReportedByTarget_Input {
  operation: MutationOperation!
  documentTarget: DocumentID_Input
}
input VerificationRequirement_VerifiesTarget_Input {
  operation: MutationOperation!
  requirementTarget: RequirementID_Input
  functionTarget: FunctionID_Input
  itemTarget: ItemID_Input
  componentTarget: ComponentID_Input
  linkTarget: LinkID_Input
}
type CallStructure {
  function: FunctionID
  structure: StructureItem
}
type StructureItem {
  id: ID!
  type: StructureType
  # optional annotation for a Branch
  annotation: String
  # reference UUID / Name / Num for: Function, Exit / ExitCondition (Exit), Replicate (DomainSet) types
  referenceID: String
  referenceName: String
  referenceNum: String
  structure: [StructureItem]
}
enum StructureType
{
  Branch
  Function
  Exit
  ExitCondition
  Loop
  LoopExit
  Parallel
  Replicate
  Select
}