Application module: Decision support ISO/TS 10303-1486:2011-10(E)
© ISO

Cover page
Table of contents
Copyright
Foreword
Introduction
1 Scope
2 Normative references
3 Terms, definitions and abbreviated terms
    3.1 Terms and definitions
    3.2 Abbreviated terms

4 Information requirements
   4.1 Required AM ARMs
   4.2 ARM type definitions
5 Module interpreted model
   5.1 Mapping specification
   5.2 MIM EXPRESS short listing
     5.2.1 MIM type definitions
     5.2.2 MIM entity definitions
 6 Module reference data

A MIM short names
B Information object registration
C ARM EXPRESS-G   EXPRESS-G
D MIM EXPRESS-G   EXPRESS-G
E Computer interpretable listings
F Application module implementation and usage guide
G Change history
Bibliography
Index

(*
ISO TC184/SC4/WG3 N2725 - ISO/TS 10303-1486 Decision support - EXPRESS ARM Long form
Supersedes ISO TC184/SC4/WG3 N2477
*)


SCHEMA Decision_support_arm_LF;


TYPE activity_item = SELECT
   (Activity,
    Activity_method,
    Analysis,
    Analysis_discipline_definition,
    Analysis_version,
    Applied_activity_assignment,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Approval,
    Assigned_document_property,
    Assigned_property,
    Certification,
    Contract,
    Contract_relationship,
    Descriptive_document_property,
    Document,
    Document_definition,
    Document_version,
    Effectivity,
    Event,
    Event_assignment,
    Evidence,
    File,
    Independent_property,
    Justification,
    Numerical_document_property,
    Organization,
    Person,
    Person_in_organization,
    Product,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project,
    Requirement_assignment,
    Requirement_collection_relationship,
    Requirement_source,
    Requirement_version_relationship,
    State,
    State_assertion,
    State_assessment,
    State_relationship,
    Tracing_relationship,
    Validation,
    Verification,
    View_definition_relationship);
END_TYPE;

TYPE alias_identification_item = identification_item ;
WHERE
  wr1: NOT ('ALIAS_IDENTIFICATION_ARM.ACTIVITY' IN TYPEOF(SELF));
  wr2: NOT ('ALIAS_IDENTIFICATION_ARM.ACTIVITY_METHOD' IN TYPEOF(SELF));
  wr3: NOT ('ALIAS_IDENTIFICATION_ARM.ACTIVITY_RELATIONSHIP' IN TYPEOF(SELF));
  wr4: NOT ('ALIAS_IDENTIFICATION_ARM.ADDRESS' IN TYPEOF(SELF));
  wr5: NOT ('ALIAS_IDENTIFICATION_ARM.ANALYSIS' IN TYPEOF(SELF));
  wr6: NOT ('ALIAS_IDENTIFICATION_ARM.ANALYSIS_VERSION' IN TYPEOF(SELF));
  wr7: NOT ('ALIAS_IDENTIFICATION_ARM.APPLIED_ACTIVITY_ASSIGNMENT' IN TYPEOF(SELF));
  wr8: NOT ('ALIAS_IDENTIFICATION_ARM.APPLIED_STATE_ASSIGNMENT' IN TYPEOF(SELF));
  wr9: NOT ('ALIAS_IDENTIFICATION_ARM.APPLIED_STATE_DEFINITION_ASSIGNMENT' IN TYPEOF(SELF));
  wr10: NOT ('ALIAS_IDENTIFICATION_ARM.APPROVAL' IN TYPEOF(SELF));
  wr11: NOT ('ALIAS_IDENTIFICATION_ARM.ASSIGNED_PROPERTY' IN TYPEOF(SELF));
  wr12: NOT ('ALIAS_IDENTIFICATION_ARM.ASSUMPTION' IN TYPEOF(SELF));
  wr13: NOT ('ALIAS_IDENTIFICATION_ARM.ASSUMPTION_RELATIONSHIP' IN TYPEOF(SELF));
  wr14: NOT ('ALIAS_IDENTIFICATION_ARM.CERTIFICATION' IN TYPEOF(SELF));
  wr15: NOT ('ALIAS_IDENTIFICATION_ARM.CLASS' IN TYPEOF(SELF));
  wr16: NOT ('ALIAS_IDENTIFICATION_ARM.CONTRACT_RELATIONSHIP' IN TYPEOF(SELF));
  wr17: NOT ('ALIAS_IDENTIFICATION_ARM.DEFINED_STATE_RELATIONSHIP' IN TYPEOF(SELF));
  wr18: NOT ('ALIAS_IDENTIFICATION_ARM.DESCRIPTIVE_DOCUMENT_PROPERTY' IN TYPEOF(SELF));
  wr19: NOT ('ALIAS_IDENTIFICATION_ARM.DIGITAL_DOCUMENT_DEFINITION' IN TYPEOF(SELF));
  wr20: NOT ('ALIAS_IDENTIFICATION_ARM.DIGITAL_FILE' IN TYPEOF(SELF));
  wr21: NOT ('ALIAS_IDENTIFICATION_ARM.DOCUMENT' IN TYPEOF(SELF));
  wr22: NOT ('ALIAS_IDENTIFICATION_ARM.DOCUMENT_ASSIGNMENT' IN TYPEOF(SELF));
  wr23: NOT ('ALIAS_IDENTIFICATION_ARM.DOCUMENT_VERSION' IN TYPEOF(SELF));
  wr24: NOT ('ALIAS_IDENTIFICATION_ARM.EFFECTIVITY' IN TYPEOF(SELF));
  wr25: NOT ('ALIAS_IDENTIFICATION_ARM.EVENT' IN TYPEOF(SELF));
  wr26: NOT ('ALIAS_IDENTIFICATION_ARM.EVIDENCE' IN TYPEOF(SELF));
  wr27: NOT ('ALIAS_IDENTIFICATION_ARM.EXTERNAL_SOURCE_IDENTIFICATION' IN TYPEOF(SELF));
  wr28: NOT ('ALIAS_IDENTIFICATION_ARM.FILE' IN TYPEOF(SELF));
  wr29: NOT ('ALIAS_IDENTIFICATION_ARM.HARDCOPY' IN TYPEOF(SELF));
  wr30: NOT ('ALIAS_IDENTIFICATION_ARM.IDENTIFICATION_RELATIONSHIP' IN TYPEOF(SELF));
  wr31: NOT ('ALIAS_IDENTIFICATION_ARM.INDEPENDENT_PROPERTY' IN TYPEOF(SELF));
  wr32: NOT ('ALIAS_IDENTIFICATION_ARM.INDEPENDENT_PROPERTY_RELATIONSHIP' IN TYPEOF(SELF));
  wr33: NOT ('ALIAS_IDENTIFICATION_ARM.INFORMATION_RIGHT' IN TYPEOF(SELF));
  wr34: NOT ('ALIAS_IDENTIFICATION_ARM.INFORMATION_USAGE_RIGHT' IN TYPEOF(SELF));
  wr35: NOT ('ALIAS_IDENTIFICATION_ARM.INFORMATION_USAGE_RIGHT_RELATIONSHIP' IN TYPEOF(SELF));
  wr36: NOT ('ALIAS_IDENTIFICATION_ARM.JUSTIFICATION' IN TYPEOF(SELF));
  wr37: NOT ('ALIAS_IDENTIFICATION_ARM.JUSTIFICATION_ASSIGNMENT' IN TYPEOF(SELF));
  wr38: NOT ('ALIAS_IDENTIFICATION_ARM.JUSTIFICATION_RELATIONSHIP' IN TYPEOF(SELF));
  wr39: NOT ('ALIAS_IDENTIFICATION_ARM.JUSTIFICATION_SUPPORT_ASSIGNMENT' IN TYPEOF(SELF));
  wr40: NOT ('ALIAS_IDENTIFICATION_ARM.NUMERICAL_DOCUMENT_PROPERTY' IN TYPEOF(SELF));
  wr41: NOT ('ALIAS_IDENTIFICATION_ARM.ORGANIZATION_OR_PERSON_IN_ORGANIZATION_ASSIGNMENT' IN TYPEOF(SELF));
  wr42: NOT ('ALIAS_IDENTIFICATION_ARM.PERSON' IN TYPEOF(SELF));
  wr43: NOT ('ALIAS_IDENTIFICATION_ARM.PERSON_IN_ORGANIZATION' IN TYPEOF(SELF));
  wr44: NOT ('ALIAS_IDENTIFICATION_ARM.PHYSICAL_DOCUMENT_DEFINITION' IN TYPEOF(SELF));
  wr45: NOT ('ALIAS_IDENTIFICATION_ARM.PRODUCT' IN TYPEOF(SELF));
  wr46: NOT ('ALIAS_IDENTIFICATION_ARM.PRODUCT_RELATIONSHIP' IN TYPEOF(SELF));
  wr47: NOT ('ALIAS_IDENTIFICATION_ARM.PRODUCT_VERSION' IN TYPEOF(SELF));
  wr48: NOT ('ALIAS_IDENTIFICATION_ARM.PRODUCT_VIEW_DEFINITION' IN TYPEOF(SELF));
  wr49: NOT ('ALIAS_IDENTIFICATION_ARM.PROJECT' IN TYPEOF(SELF));
  wr50: NOT ('ALIAS_IDENTIFICATION_ARM.REPRESENTATION' IN TYPEOF(SELF));
  wr51: NOT ('ALIAS_IDENTIFICATION_ARM.REPRESENTATION_ITEM' IN TYPEOF(SELF));
  wr52: NOT ('ALIAS_IDENTIFICATION_ARM.REQUIREMENT' IN TYPEOF(SELF));
  wr53: NOT ('ALIAS_IDENTIFICATION_ARM.REQUIREMENT_ASSIGNMENT' IN TYPEOF(SELF));
  wr54: NOT ('ALIAS_IDENTIFICATION_ARM.REQUIREMENT_SOURCE' IN TYPEOF(SELF));
  wr55: NOT ('ALIAS_IDENTIFICATION_ARM.REQUIREMENT_VERSION' IN TYPEOF(SELF));
  wr56: NOT ('ALIAS_IDENTIFICATION_ARM.REQUIREMENT_VERSION_RELATIONSHIP' IN TYPEOF(SELF));
  wr57: NOT ('ALIAS_IDENTIFICATION_ARM.REQUIREMENT_VIEW_DEFINITION' IN TYPEOF(SELF));
  wr58: NOT ('ALIAS_IDENTIFICATION_ARM.SECURITY_CLASSIFICATION_ASSIGNMENT' IN TYPEOF(SELF));
  wr59: NOT ('ALIAS_IDENTIFICATION_ARM.STATE' IN TYPEOF(SELF));
  wr60: NOT ('ALIAS_IDENTIFICATION_ARM.STATE_ASSERTION' IN TYPEOF(SELF));
  wr61: NOT ('ALIAS_IDENTIFICATION_ARM.STATE_ASSESSMENT' IN TYPEOF(SELF));
  wr62: NOT ('ALIAS_IDENTIFICATION_ARM.STATE_DEFINITION' IN TYPEOF(SELF));
  wr63: NOT ('ALIAS_IDENTIFICATION_ARM.STATE_DEFINITION_RELATIONSHIP' IN TYPEOF(SELF));
  wr64: NOT ('ALIAS_IDENTIFICATION_ARM.STATE_RELATIONSHIP' IN TYPEOF(SELF));
  wr65: NOT ('ALIAS_IDENTIFICATION_ARM.STATE_TRANSITION_DEFINITION' IN TYPEOF(SELF));
  wr66: NOT ('ALIAS_IDENTIFICATION_ARM.VALIDATION' IN TYPEOF(SELF));
  wr67: NOT ('ALIAS_IDENTIFICATION_ARM.VERIFICATION' IN TYPEOF(SELF));
  wr68: NOT ('ALIAS_IDENTIFICATION_ARM.VIEW_DEFINITION_CONTEXT' IN TYPEOF(SELF));
  wr69: NOT ('ALIAS_IDENTIFICATION_ARM.VIEW_DEFINITION_RELATIONSHIP' IN TYPEOF(SELF));
  wr70: NOT ('ALIAS_IDENTIFICATION_ARM.VIEW_DEFINITION_USAGE' IN TYPEOF(SELF));
END_TYPE;

TYPE analysed_item = SELECT
   (Activity,
    Activity_method,
    Activity_relationship,
    Assigned_property,
    Evidence,
    Organization,
    Organization_relationship,
    Product,
    Product_relationship,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project_relationship,
    Requirement_assignment,
    State,
    State_assessment,
    State_definition,
    State_role,
    Validation,
    Verification,
    Verification_relationship,
    View_definition_context,
    View_definition_relationship);
END_TYPE;

TYPE any_number_value = NUMBER;
END_TYPE;

TYPE any_string_value = STRING;
END_TYPE;

TYPE approval_item = SELECT
   (Activity,
    Activity_actual,
    Activity_method,
    Address_assignment,
    Analysis_discipline_definition,
    Analysis_version,
    Applied_activity_assignment,
    Applied_information_usage_right,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Assigned_property,
    Assumption,
    Assumption_assignment,
    Assumption_relationship,
    Certification,
    Certification_assignment,
    Classification_assignment,
    Contract,
    Contract_assignment,
    Contract_relationship,
    Date_or_date_time_assignment,
    Descriptive_document_property,
    Document_assignment,
    Document_definition,
    Document_version,
    Effectivity,
    Effectivity_assignment,
    Event,
    Event_assignment,
    Evidence,
    Identification_assignment,
    Identification_relationship,
    Independent_property,
    Independent_property_relationship,
    Information_usage_right,
    Item_assumed,
    Justification,
    Justification_assignment,
    Justification_relationship,
    Justification_support_assignment,
    Numerical_document_property,
    Organization_or_person_in_organization_assignment,
    Organization_relationship,
    Person_in_organization,
    Physical_document_definition,
    Product,
    Product_relationship,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project,
    Project_assignment,
    Requirement_assignment,
    Requirement_source,
    Security_classification,
    Security_classification_assignment,
    State_assessment,
    State_definition,
    State_definition_relationship,
    State_relationship,
    Supplied_part_relationship,
    Validation,
    Verification,
    Verification_relationship,
    View_definition_context,
    View_definition_relationship);
END_TYPE;

TYPE assigned_document_select = SELECT
   (Document,
    Document_definition,
    Document_version,
    File);
END_TYPE;

TYPE assumed_item = SELECT
   (Activity,
    Applied_activity_assignment,
    Applied_state_assignment,
    Approval,
    Approval_assignment,
    Assigned_property,
    Contract,
    Contract_assignment,
    Product,
    Product_version,
    Project,
    Project_assignment,
    Requirement,
    Requirement_assignment,
    View_definition_relationship);
END_TYPE;

TYPE assumption_item = SELECT
   (Activity,
    Approval,
    Contract,
    Product,
    Product_version,
    Project,
    Requirement);
END_TYPE;

TYPE certification_item = SELECT
   (Activity,
    Activity_method,
    Analysis_assignment,
    Analysis_discipline_definition,
    Analysis_version,
    Approving_person_organization,
    Assigned_property,
    Document,
    Document_version,
    Evidence,
    Justification,
    Product,
    Product_version,
    Product_version_relationship,
    Project,
    State_definition,
    View_definition_relationship);
END_TYPE;

TYPE classification_item = SELECT
   (Activity,
    Activity_method,
    Activity_relationship,
    Activity_status,
    Address,
    Address_assignment,
    Analysis,
    Analysis_assignment,
    Analysis_discipline_definition,
    Analysis_version,
    Applied_activity_assignment,
    Applied_information_usage_right,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Approval,
    Approval_assignment,
    Approval_relationship,
    Approval_status,
    Approving_person_organization,
    Assigned_property,
    Assumption,
    Assumption_assignment,
    Assumption_relationship,
    Attribute_translation_assignment,
    Calendar_date,
    Certification,
    Certification_assignment,
    Class,
    Context_dependent_unit,
    Contract,
    Contract_assignment,
    Contract_relationship,
    Conversion_based_unit,
    Date_or_date_time_assignment,
    Date_time,
    Defined_state_relationship,
    Derived_unit,
    Descriptive_document_property,
    Digital_document_definition,
    Digital_file,
    Document,
    Document_assignment,
    Document_location_identification,
    Document_property_representation,
    Document_version,
    Effectivity,
    Effectivity_assignment,
    Effectivity_relationship,
    Event,
    Event_assignment,
    Event_relationship,
    Evidence,
    External_item_identification,
    External_source_identification,
    File,
    File_location_identification,
    Hardcopy,
    Identification_assignment,
    Identification_relationship,
    Independent_property,
    Independent_property_relationship,
    Information_right,
    Information_usage_right,
    Information_usage_right_relationship,
    Item_assumed,
    Justification,
    Justification_assignment,
    Justification_relationship,
    Justification_support_assignment,
    Language,
    Language_indication,
    Local_time,
    Numerical_document_property,
    Numerical_item_with_unit,
    Organization,
    Organization_or_person_in_organization_assignment,
    Organization_relationship,
    Partial_document_assignment,
    Person,
    Person_in_organization,
    Physical_document_definition,
    Product,
    Product_relationship,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project,
    Project_assignment,
    Project_relationship,
    Property_representation,
    Representation,
    Representation_context,
    Representation_item,
    Representation_relationship,
    Requirement,
    Requirement_assignment,
    Requirement_collection_relationship,
    Requirement_source,
    Requirement_version,
    Requirement_version_relationship,
    Requirement_view_definition,
    Security_classification,
    Security_classification_assignment,
    State,
    State_assertion,
    State_assessment,
    State_definition,
    State_definition_relationship,
    State_relationship,
    State_role,
    String_representation_item,
    Supplied_part_relationship,
    Time_interval_relationship,
    Tracing_relationship,
    Uncertainty_with_unit,
    Unit,
    Validation,
    Value_with_unit,
    Verification,
    Verification_relationship,
    View_definition_context,
    View_definition_relationship);
END_TYPE;

TYPE collection_assignment_select = SELECT
   (Activity,
    Activity_method,
    Contract,
    Organization,
    Product,
    Product_version,
    Product_view_definition,
    Project);
END_TYPE;

TYPE collection_member_select = SELECT
   (Activity,
    Activity_method,
    Activity_relationship,
    Activity_status,
    Address,
    Address_assignment,
    Analysis_assignment,
    Applied_activity_assignment,
    Applied_information_usage_right,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Approval,
    Approval_assignment,
    Approval_relationship,
    Approval_status,
    Approving_person_organization,
    Assigned_property,
    Assumption,
    Assumption_assignment,
    Assumption_relationship,
    Attribute_translation_assignment,
    Calendar_date,
    Certification,
    Certification_assignment,
    Class,
    Classification_assignment,
    Collection_assignment,
    Collection_membership,
    Contract,
    Contract_assignment,
    Contract_relationship,
    Date_or_date_time_assignment,
    Date_time,
    Defined_state_relationship,
    Derived_unit_element,
    Document_assignment,
    Effectivity,
    Effectivity_assignment,
    Effectivity_relationship,
    Event,
    Event_assignment,
    Event_relationship,
    Evidence,
    External_source,
    External_source_identification,
    File,
    Identification_assignment,
    Identification_relationship,
    Independent_property,
    Independent_property_relationship,
    Information_right,
    Information_usage_right,
    Information_usage_right_relationship,
    Item_assumed,
    Justification,
    Justification_assignment,
    Justification_relationship,
    Justification_support_assignment,
    Language,
    Language_indication,
    Local_time,
    Organization,
    Organization_or_person_in_organization_assignment,
    Organization_relationship,
    Person,
    Person_in_organization,
    Product,
    Product_relationship,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project,
    Project_assignment,
    Project_relationship,
    Property_definition_representation,
    Representation,
    Representation_context,
    Representation_item,
    Representation_relationship,
    Requirement_assignment,
    Requirement_satisfied_by,
    Requirement_source,
    Same_as_external_item,
    Security_classification,
    Security_classification_assignment,
    State,
    State_assertion,
    State_assessment,
    State_definition,
    State_definition_relationship,
    State_definition_role,
    State_relationship,
    State_role,
    Time_interval,
    Time_interval_relationship,
    Time_offset,
    Unit,
    Validation,
    Value_with_unit,
    Verification,
    Verification_relationship,
    View_definition_context,
    View_definition_relationship);
END_TYPE;

TYPE contract_item = SELECT
   (Activity,
    Activity_method,
    Analysis_version,
    Applied_activity_assignment,
    Document,
    Document_version,
    Information_usage_right,
    Justification,
    Organization,
    organization_or_person_in_organization_item,
    Person_in_organization,
    Product_version,
    Project,
    Requirement,
    Requirement_assignment,
    Requirement_collection_relationship,
    Requirement_source,
    Requirement_version,
    Requirement_version_relationship,
    Requirement_view_definition,
    Security_classification,
    Tracing_relationship,
    Validation,
    Verification);
END_TYPE;

TYPE date_or_date_time_item = SELECT
   (Activity,
    Activity_method,
    Activity_relationship,
    Address_assignment,
    Analysis_assignment,
    Analysis_discipline_definition,
    Applied_activity_assignment,
    Applied_information_usage_right,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Approval,
    Approving_person_organization,
    Assigned_property,
    Assumption,
    Assumption_assignment,
    Assumption_relationship,
    Certification,
    Certification_assignment,
    Classification_assignment,
    Contract,
    Contract_assignment,
    Contract_relationship,
    Date_or_date_time_assignment,
    Descriptive_document_property,
    Digital_file,
    Document,
    Document_assignment,
    Document_definition,
    Effectivity,
    Effectivity_assignment,
    Event_assignment,
    Evidence,
    Hardcopy,
    Identification_assignment,
    Identification_relationship,
    Independent_property,
    Independent_property_relationship,
    Information_usage_right,
    Item_assumed,
    Justification,
    Justification_assignment,
    Justification_relationship,
    Justification_support_assignment,
    Numerical_document_property,
    Organization_or_person_in_organization_assignment,
    Organization_relationship,
    Person,
    Person_in_organization,
    Product_relationship,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project,
    Project_assignment,
    Property_representation,
    Representation,
    Requirement,
    Requirement_assignment,
    Requirement_collection_relationship,
    Requirement_source,
    Security_classification,
    Security_classification_assignment,
    State,
    State_assertion,
    State_assessment,
    State_definition,
    State_definition_relationship,
    State_relationship,
    Tracing_relationship,
    Validation,
    Verification,
    Verification_relationship,
    View_definition_context);
END_TYPE;

TYPE date_or_date_time_select = SELECT
   (Calendar_date,
    Date_time);
END_TYPE;

TYPE date_or_event = SELECT
   (Calendar_date,
    Date_time,
    Event);
END_TYPE;

TYPE day_in_month_number = INTEGER ;
WHERE
  WR1: {1 <= SELF <= 31};
END_TYPE;

TYPE descriptive_or_numerical = SELECT
   (Descriptive_document_property,
    Numerical_document_property);
END_TYPE;

TYPE document_property_item = property_assignment_select ;
WHERE
  wr1: NOT ('DOCUMENT_PROPERTIES_ARM.ACTIVITY' IN TYPEOF(SELF));
  wr2: NOT ('DOCUMENT_PROPERTIES_ARM.ACTIVITY_HAPPENING' IN TYPEOF(SELF));
  wr3: NOT ('DOCUMENT_PROPERTIES_ARM.ACTIVITY_METHOD' IN TYPEOF(SELF));
  wr4: NOT ('DOCUMENT_PROPERTIES_ARM.ADDRESS' IN TYPEOF(SELF));
  wr5: NOT ('DOCUMENT_PROPERTIES_ARM.ANALYSIS_ASSIGNMENT' IN TYPEOF(SELF));
  wr6: NOT ('DOCUMENT_PROPERTIES_ARM.APPLIED_ACTIVITY_ASSIGNMENT' IN TYPEOF(SELF));
  wr7: NOT ('DOCUMENT_PROPERTIES_ARM.APPLIED_STATE_ASSIGNMENT' IN TYPEOF(SELF));
  wr8: NOT ('DOCUMENT_PROPERTIES_ARM.APPLIED_STATE_DEFINITION_ASSIGNMENT' IN TYPEOF(SELF));
  wr9: NOT ('DOCUMENT_PROPERTIES_ARM.ASSIGNED_PROPERTY' IN TYPEOF(SELF));
  wr10: NOT ('DOCUMENT_PROPERTIES_ARM.DOCUMENT_ASSIGNMENT' IN TYPEOF(SELF));
  wr11: NOT ('DOCUMENT_PROPERTIES_ARM.EVENT' IN TYPEOF(SELF));
  wr12: NOT ('DOCUMENT_PROPERTIES_ARM.EVIDENCE' IN TYPEOF(SELF));
  wr13: NOT ('DOCUMENT_PROPERTIES_ARM.INDEPENDENT_PROPERTY' IN TYPEOF(SELF));
  wr14: NOT ('DOCUMENT_PROPERTIES_ARM.INDEPENDENT_PROPERTY_RELATIONSHIP' IN TYPEOF(SELF));
  wr15: NOT ('DOCUMENT_PROPERTIES_ARM.INFORMATION_USAGE_RIGHT' IN TYPEOF(SELF));
  wr16: NOT ('DOCUMENT_PROPERTIES_ARM.ORGANIZATION_OR_PERSON_IN_ORGANIZATION_ASSIGNMENT' IN TYPEOF(SELF));
  wr17: NOT ('DOCUMENT_PROPERTIES_ARM.PERSON' IN TYPEOF(SELF));
  wr18: NOT ('DOCUMENT_PROPERTIES_ARM.PERSON_IN_ORGANIZATION' IN TYPEOF(SELF));
  wr19: NOT ('DOCUMENT_PROPERTIES_ARM.PRODUCT' IN TYPEOF(SELF));
  wr20: NOT ('DOCUMENT_PROPERTIES_ARM.PRODUCT_VERSION' IN TYPEOF(SELF));
  wr21: NOT ('DOCUMENT_PROPERTIES_ARM.PRODUCT_VERSION_RELATIONSHIP' IN TYPEOF(SELF));
  wr22: NOT ('DOCUMENT_PROPERTIES_ARM.PRODUCT_VIEW_DEFINITION' IN TYPEOF(SELF));
  wr23: NOT ('DOCUMENT_PROPERTIES_ARM.PROJECT' IN TYPEOF(SELF));
  wr24: NOT ('DOCUMENT_PROPERTIES_ARM.PROPERTY_DEFINITION_REPRESENTATION' IN TYPEOF(SELF));
  wr25: NOT ('DOCUMENT_PROPERTIES_ARM.REPRESENTATION' IN TYPEOF(SELF));
  wr26: NOT ('DOCUMENT_PROPERTIES_ARM.REPRESENTATION_CONTEXT' IN TYPEOF(SELF));
  wr27: NOT ('DOCUMENT_PROPERTIES_ARM.REPRESENTATION_ITEM' IN TYPEOF(SELF));
  wr28: NOT ('DOCUMENT_PROPERTIES_ARM.REQUIREMENT_SOURCE' IN TYPEOF(SELF));
  wr29: NOT ('DOCUMENT_PROPERTIES_ARM.SECURITY_CLASSIFICATION' IN TYPEOF(SELF));
  wr30: NOT ('DOCUMENT_PROPERTIES_ARM.STATE' IN TYPEOF(SELF));
  wr31: NOT ('DOCUMENT_PROPERTIES_ARM.STATE_ASSERTION' IN TYPEOF(SELF));
  wr32: NOT ('DOCUMENT_PROPERTIES_ARM.STATE_ASSESSMENT' IN TYPEOF(SELF));
  wr33: NOT ('DOCUMENT_PROPERTIES_ARM.STATE_DEFINITION' IN TYPEOF(SELF));
  wr34: NOT ('DOCUMENT_PROPERTIES_ARM.STATE_DEFINITION_RELATIONSHIP' IN TYPEOF(SELF));
  wr35: NOT ('DOCUMENT_PROPERTIES_ARM.STATE_RELATIONSHIP' IN TYPEOF(SELF));
  wr36: NOT ('DOCUMENT_PROPERTIES_ARM.VERIFICATION' IN TYPEOF(SELF));
  wr37: NOT ('DOCUMENT_PROPERTIES_ARM.VERIFICATION_RELATIONSHIP' IN TYPEOF(SELF));
  wr38: NOT ('DOCUMENT_PROPERTIES_ARM.VIEW_DEFINITION_RELATIONSHIP' IN TYPEOF(SELF));
END_TYPE;

TYPE documented_element_select = SELECT
   (Activity,
    Activity_method,
    Activity_relationship,
    Address_assignment,
    Alias_identification,
    Analysis,
    Applied_activity_assignment,
    Applied_information_usage_right,
    Approval,
    Approval_assignment,
    Assigned_property,
    Assumption,
    Assumption_assignment,
    Assumption_relationship,
    Certification,
    Certification_assignment,
    Class,
    Classification_assignment,
    Contract,
    Contract_assignment,
    Contract_relationship,
    Date_or_date_time_assignment,
    Digital_document_definition,
    Digital_file,
    Document_assignment,
    Effectivity,
    Effectivity_assignment,
    Event_assignment,
    Evidence,
    External_item_identification,
    Hardcopy,
    Identification_assignment,
    Independent_property,
    Independent_property_relationship,
    Information_right,
    Information_usage_right,
    Information_usage_right_relationship,
    Item_assumed,
    Justification,
    Justification_assignment,
    Justification_relationship,
    Justification_support_assignment,
    Organization,
    Organization_or_person_in_organization_assignment,
    Organization_relationship,
    Person,
    Person_in_organization,
    Physical_document_definition,
    Product,
    Product_relationship,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project,
    Project_assignment,
    Property_representation,
    Representation,
    Representation_item,
    Requirement_assignment,
    Requirement_source,
    Security_classification,
    Security_classification_assignment,
    State,
    State_assertion,
    State_assessment,
    State_definition,
    State_definition_relationship,
    Validation,
    Verification,
    View_definition_relationship);
END_TYPE;

TYPE effectivity_item = SELECT
   (Activity,
    Activity_method,
    Address_assignment,
    Analysis_assignment,
    Applied_activity_assignment,
    Applied_information_usage_right,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Approval_assignment,
    Assigned_property,
    Assumption,
    Assumption_assignment,
    Assumption_relationship,
    Attribute_translation_assignment,
    Certification_assignment,
    Classification_assignment,
    Contract_assignment,
    Date_or_date_time_assignment,
    Document_assignment,
    Document_location_identification,
    Effectivity_assignment,
    Event,
    Event_assignment,
    Evidence,
    External_source_identification,
    File,
    Identification_assignment,
    Identification_relationship,
    Item_assumed,
    Justification,
    Justification_assignment,
    Justification_relationship,
    Justification_support_assignment,
    Organization_or_person_in_organization_assignment,
    Organization_relationship,
    Person_in_organization,
    Product,
    Product_relationship,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project_assignment,
    Requirement_assignment,
    Requirement_collection_relationship,
    Requirement_source,
    Security_classification_assignment,
    State_definition_relationship,
    Validation,
    Verification,
    Verification_relationship,
    View_definition_relationship,
    View_definition_usage);
END_TYPE;

TYPE event_item = SELECT
   (Activity,
    Activity_method,
    Activity_relationship,
    Applied_state_assignment,
    Approval,
    Certification,
    Contract,
    Contract_assignment,
    Contract_relationship,
    Evidence,
    Independent_property,
    Independent_property_relationship,
    Justification,
    Product,
    Product_version,
    Product_view_definition,
    Project,
    Project_assignment,
    Representation,
    Representation_item,
    State,
    State_definition,
    State_definition_relationship,
    State_relationship,
    Verification,
    Verification_relationship,
    View_definition_relationship);
END_TYPE;

TYPE evidence_item = SELECT
   (Activity_actual,
    Activity_method,
    Activity_relationship,
    Activity_status,
    Analysis_assignment,
    Analysis_version,
    Applied_activity_assignment,
    Applied_independent_property,
    Applied_information_usage_right,
    Applied_state_assignment,
    Approval_assignment,
    Assigned_property,
    Certification_assignment,
    Classification_assignment,
    Contract_assignment,
    Date_or_date_time_assignment,
    Defined_state_relationship,
    Effectivity_assignment,
    Event_assignment,
    Justification_assignment,
    Justification_relationship,
    Justification_support_assignment,
    Organization_or_person_in_organization_assignment,
    Person,
    Person_in_organization,
    Product,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project_assignment,
    Representation,
    Representation_context,
    Representation_item,
    Security_classification_assignment,
    State,
    State_assertion,
    State_assessment,
    State_relationship,
    Validation,
    Verification,
    View_definition_context,
    View_definition_relationship);
END_TYPE;

TYPE evidence_support_item = SELECT
   (Validation,
    Verification);
END_TYPE;

TYPE external_identification_item = SELECT
   (Document_definition,
    File,
    Organization,
    Person_in_organization,
    Product,
    Project);
END_TYPE;

TYPE hour_in_day = INTEGER ;
WHERE
  WR1: {0 <= SELF < 24};
END_TYPE;

TYPE identification_item = SELECT
   (Activity,
    Activity_method,
    Activity_relationship,
    Address,
    Analysis,
    Analysis_version,
    Applied_activity_assignment,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Approval,
    Approval_status,
    Assigned_property,
    Assumption,
    Assumption_relationship,
    Certification,
    Class,
    Contract,
    Contract_relationship,
    Defined_state_relationship,
    Descriptive_document_property,
    Digital_document_definition,
    Digital_file,
    Document,
    Document_assignment,
    Document_version,
    Effectivity,
    Event,
    Evidence,
    External_source_identification,
    File,
    Hardcopy,
    Identification_relationship,
    Independent_property,
    Independent_property_relationship,
    Information_right,
    Information_usage_right,
    Information_usage_right_relationship,
    Justification,
    Justification_assignment,
    Justification_relationship,
    Justification_support_assignment,
    Numerical_document_property,
    Organization,
    Organization_or_person_in_organization_assignment,
    Person,
    Person_in_organization,
    Physical_document_definition,
    Product,
    Product_relationship,
    Product_version,
    Product_view_definition,
    Project,
    Representation,
    Representation_item,
    Requirement,
    Requirement_assignment,
    Requirement_source,
    Requirement_version,
    Requirement_version_relationship,
    Requirement_view_definition,
    Security_classification,
    Security_classification_assignment,
    State,
    State_assertion,
    State_assessment,
    State_definition,
    State_definition_relationship,
    State_relationship,
    State_transition_definition,
    Validation,
    Verification,
    View_definition_context,
    View_definition_relationship,
    View_definition_usage);
END_TYPE;

TYPE identifier = STRING;
END_TYPE;

TYPE information_usage_right_item = SELECT
   (Activity_method,
    Analysis_assignment,
    Analysis_discipline_definition,
    Applied_information_usage_right,
    Assigned_property,
    Certification,
    Certification_assignment,
    Contract,
    Contract_relationship,
    Digital_document_definition,
    Digital_file,
    Document,
    Document_version,
    Evidence,
    External_item_identification,
    Hardcopy,
    Information_right,
    Information_usage_right,
    Information_usage_right_relationship,
    Justification,
    Organization,
    Person_in_organization,
    Physical_document_definition,
    Product,
    Product_version,
    Product_view_definition,
    Project,
    Representation_item,
    Requirement,
    Requirement_assignment,
    Requirement_version,
    Requirement_view_definition,
    Security_classification,
    Security_classification_assignment,
    Supplied_part_relationship,
    Validation,
    Verification,
    View_definition_relationship);
END_TYPE;

TYPE justification_item = SELECT
   (Activity,
    Activity_method,
    Analysis_assignment,
    Applied_activity_assignment,
    Applied_information_usage_right,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Approval,
    Approval_assignment,
    Assigned_property,
    Assumption,
    Assumption_assignment,
    Assumption_relationship,
    Certification,
    Classification_assignment,
    Contract,
    Contract_relationship,
    Descriptive_document_property,
    Document_assignment,
    Document_definition,
    Effectivity,
    Evidence,
    Independent_property,
    Independent_property_relationship,
    Information_usage_right,
    Numerical_document_property,
    Product,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project_assignment,
    Property_value_representation,
    Requirement_assignment,
    Security_classification,
    State_assertion,
    State_assessment,
    Validation,
    Verification,
    View_definition_relationship);
END_TYPE;

TYPE justification_support_item = SELECT
   (Activity,
    Activity_method,
    Analysis_assignment,
    Applied_activity_assignment,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Approval,
    Assigned_property,
    Assumption,
    Assumption_assignment,
    Assumption_relationship,
    Certification,
    Contract,
    Contract_relationship,
    Descriptive_document_property,
    Document,
    Document_definition,
    Document_version,
    Effectivity,
    Event,
    Evidence,
    Independent_property,
    Independent_property_relationship,
    Numerical_document_property,
    Organization_or_person_in_organization_assignment,
    Product,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project,
    State,
    State_definition,
    State_definition_relationship,
    State_relationship,
    Validation,
    Verification,
    View_definition_context,
    View_definition_relationship);
END_TYPE;

TYPE label = STRING;
END_TYPE;

TYPE length_measure = REAL;
END_TYPE;

TYPE measure_value = SELECT
   (any_number_value,
    any_string_value,
    length_measure,
    plane_angle_measure);
END_TYPE;

TYPE minute_in_hour = INTEGER ;
WHERE
  WR1: {0 <= SELF <= 59};
END_TYPE;

TYPE month_in_year_number = INTEGER ;
WHERE
  WR1: {1 <= SELF <= 12};
END_TYPE;

TYPE offset_orientation = ENUMERATION OF
   (ahead,
    exact,
    behind);
END_TYPE;

TYPE organization_or_person_in_organization_item = SELECT
   (Activity,
    Activity_method,
    Activity_relationship,
    Address,
    Address_assignment,
    Analysis,
    Analysis_discipline_definition,
    Analysis_version,
    Applied_activity_assignment,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Approval,
    Approval_status,
    Assigned_property,
    Assumption,
    Assumption_assignment,
    Assumption_relationship,
    Certification,
    Certification_assignment,
    Class,
    Classification_assignment,
    Contract,
    Contract_assignment,
    Contract_relationship,
    Date_or_date_time_assignment,
    Descriptive_document_property,
    Digital_file,
    Document,
    Document_assignment,
    Effectivity,
    Effectivity_assignment,
    Event,
    Event_assignment,
    Evidence,
    Hardcopy,
    Identification_assignment,
    Identification_relationship,
    Independent_property,
    Independent_property_relationship,
    Information_usage_right,
    Item_assumed,
    Justification,
    Justification_assignment,
    Justification_relationship,
    Justification_support_assignment,
    Numerical_document_property,
    Organization,
    Organization_or_person_in_organization_assignment,
    Person,
    Person_in_organization,
    Product,
    Product_relationship,
    Product_version,
    Product_view_definition,
    Project,
    Project_assignment,
    Property_representation,
    Representation,
    Requirement,
    Requirement_assignment,
    Requirement_collection_relationship,
    Requirement_source,
    Requirement_version_relationship,
    Security_classification,
    Security_classification_assignment,
    State,
    State_assertion,
    State_assessment,
    State_definition,
    State_definition_relationship,
    State_relationship,
    Supplied_part_relationship,
    Tracing_relationship,
    Validation,
    Verification,
    View_definition_context,
    View_definition_relationship);
END_TYPE;

TYPE organization_or_person_in_organization_select = SELECT
   (Organization,
    Person_in_organization);
END_TYPE;

TYPE plane_angle_measure = REAL;
END_TYPE;

TYPE project_item = SELECT
   (Activity,
    Activity_method,
    Applied_activity_assignment,
    Independent_property,
    Organization,
    Person_in_organization,
    Product,
    Product_version,
    Product_view_definition,
    Representation,
    View_definition_relationship);
END_TYPE;

TYPE property_assignment_select = SELECT
   (Activity,
    Activity_happening,
    Activity_method,
    Address,
    Analysis_assignment,
    Applied_activity_assignment,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Assigned_property,
    Document_assignment,
    Document_definition,
    Event,
    Evidence,
    File,
    Independent_property,
    Independent_property_relationship,
    Information_usage_right,
    Organization_or_person_in_organization_assignment,
    Person,
    Person_in_organization,
    Product,
    Product_version,
    Product_version_relationship,
    Product_view_definition,
    Project,
    Property_definition_representation,
    Representation,
    Representation_context,
    Representation_item,
    Requirement_source,
    Security_classification,
    State,
    State_assertion,
    State_assessment,
    State_definition,
    State_definition_relationship,
    State_relationship,
    Verification,
    Verification_relationship,
    View_definition_relationship);
END_TYPE;

TYPE representation_proxy_select = SELECT
   (Collection_version,
    Document_version);
END_TYPE;

TYPE represented_definition = SELECT
   (Assigned_property,
    Independent_property);
END_TYPE;

TYPE requirement_assignment_item = SELECT
   (Activity_method,
    Analysis_discipline_definition,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Document_version,
    Product,
    Product_version,
    Product_view_definition,
    Project,
    State,
    State_definition,
    Validation,
    Verification,
    View_definition_relationship);
END_TYPE;

TYPE requirement_satisfaction_item = SELECT
   (requirement_assignment_item);
END_TYPE;

TYPE requirement_source_item = SELECT
   (Activity_method,
    Analysis_discipline_definition,
    Applied_state_assignment,
    Applied_state_definition_assignment,
    Approval_assignment,
    Approving_person_organization,
    Certification_assignment,
    Contract_assignment,
    Document_version,
    Organization,
    Organization_or_person_in_organization_assignment,
    Person_in_organization,
    Product,
    Product_version,
    Product_view_definition,
    Project_assignment,
    State,
    State_definition,
    Validation,
    Verification,
    View_definition_relationship);
END_TYPE;

TYPE same_as_item = SELECT
   (Address,
    Approval,
    Approval_status,
    Calendar_date,
    Certification,
    Contract,
    Date_time,
    Derived_unit_element,
    Event,
    External_source,
    External_source_identification,
    Independent_property,
    Information_right,
    Information_usage_right,
    Language,
    Language_indication,
    Local_time,
    Organization,
    Person,
    Representation_context,
    Requirement_source,
    Security_classification,
    Time_interval,
    Time_offset,
    Unit,
    Value_with_unit,
    View_definition_context);
END_TYPE;

TYPE second_in_minute = REAL ;
WHERE
  WR1: {0 <= SELF <= 60.000000};
END_TYPE;

TYPE security_classification_item = SELECT
   (Activity,
    Activity_method,
    Analysis_version,
    Applied_activity_assignment,
    Assigned_property,
    Digital_document_definition,
    Digital_file,
    Document,
    Document_assignment,
    Document_version,
    Event,
    Evidence,
    Hardcopy,
    Physical_document_definition,
    Product,
    Product_relationship,
    Product_version,
    Product_view_definition,
    Project_relationship,
    Requirement,
    Requirement_assignment,
    Requirement_collection_relationship,
    Requirement_source,
    Requirement_version,
    Requirement_version_relationship,
    Requirement_view_definition,
    Tracing_relationship,
    Validation,
    Verification);
END_TYPE;

TYPE state_definition_of_item = SELECT
   (Assumption);
END_TYPE;

TYPE state_of_item = SELECT
   (Assumption,
    evidence_support_item);
END_TYPE;

TYPE string_select = SELECT
   (Activity,
    Activity_method,
    Activity_relationship,
    Applied_activity_assignment,
    Approval,
    Approval_relationship,
    Approval_status,
    Assigned_property,
    Certification,
    Contract,
    Contract_relationship,
    Date_or_date_time_assignment,
    Digital_document_definition,
    Document,
    Document_assignment,
    Document_version,
    Event,
    Evidence,
    External_source_identification,
    Identification_assignment,
    Independent_property,
    Independent_property_relationship,
    Information_right,
    Information_usage_right,
    Justification,
    Justification_assignment,
    Justification_relationship,
    Justification_support_assignment,
    Organization_relationship,
    Person_in_organization,
    Physical_document_definition,
    Product,
    Product_relationship,
    Product_version,
    Product_view_definition,
    Project,
    Project_assignment,
    Project_relationship,
    Representation_item,
    Requirement,
    Requirement_assignment,
    Requirement_collection_relationship,
    Requirement_source,
    Requirement_version,
    Requirement_version_relationship,
    Requirement_view_definition,
    State,
    State_definition,
    State_definition_relationship,
    State_relationship,
    Tracing_relationship,
    Validation,
    Verification,
    View_definition_relationship);
END_TYPE;

TYPE text = STRING;
END_TYPE;

TYPE validation_item = SELECT
   (Activity_method,
    Organization_or_person_in_organization_assignment,
    Product_version,
    State_definition);
END_TYPE;

TYPE year_number = INTEGER;
END_TYPE;

ENTITY Activity;
  id : STRING;
  name : STRING;
  description : OPTIONAL STRING;
  chosen_method : Activity_method;
END_ENTITY;

ENTITY Activity_actual
  SUBTYPE OF (Activity);
END_ENTITY;

ENTITY Activity_happening
  SUBTYPE OF (Activity_relationship);
  SELF\Activity_relationship.relating_activity : Activity_actual;
DERIVE
  actual : Activity_actual := SELF\Activity_relationship.relating_activity;
  predicted : Activity := SELF\Activity_relationship.related_activity;
WHERE
  WR1: NOT ('DECISION_SUPPORT_ARM_LF.ACTIVITY_ACTUAL' IN TYPEOF(predicted));
END_ENTITY;

ENTITY Activity_method;
  name : STRING;
  description : OPTIONAL STRING;
  consequence : OPTIONAL STRING;
  purpose : STRING;
END_ENTITY;

ENTITY Activity_relationship;
  name : STRING;
  description : OPTIONAL STRING;
  relating_activity : Activity;
  related_activity : Activity;
END_ENTITY;

ENTITY Activity_status;
  assigned_activity : Activity;
  status : STRING;
END_ENTITY;

ENTITY Address;
  name : OPTIONAL STRING;
  street_number : OPTIONAL STRING;
  street : OPTIONAL STRING;
  postal_box : OPTIONAL STRING;
  town : OPTIONAL STRING;
  region : OPTIONAL STRING;
  postal_code : OPTIONAL STRING;
  country : OPTIONAL STRING;
  internal_location : OPTIONAL STRING;
  facsimile_number : OPTIONAL STRING;
  telephone_number : OPTIONAL STRING;
  electronic_mail_address : OPTIONAL STRING;
  telex_number : OPTIONAL STRING;
  url : OPTIONAL STRING;
WHERE
  WR1: (EXISTS(street_number) OR EXISTS(street) OR EXISTS(postal_box) OR EXISTS(town) OR EXISTS(region) OR EXISTS(postal_code) OR EXISTS(country) OR EXISTS(internal_location) OR EXISTS(facsimile_number) OR EXISTS(telephone_number) OR EXISTS(electronic_mail_address) OR EXISTS(telex_number));
END_ENTITY;

ENTITY Address_assignment;
  address_type : OPTIONAL STRING;
  assigned_address : Address;
  located_person_organizations : SET[1:?] OF organization_or_person_in_organization_select;
END_ENTITY;

ENTITY Alias_identification
  SUBTYPE OF (Identification_assignment);
  SELF\Identification_assignment.items : SET[1:?] OF alias_identification_item;
DERIVE
  SELF\Identification_assignment.role : STRING := 'alias';
END_ENTITY;

ENTITY Amount_of_substance_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Analysis
  SUBTYPE OF (Product);
END_ENTITY;

ENTITY Analysis_assignment;
  analysis : Analysis_version;
  applied_to : analysed_item;
END_ENTITY;

ENTITY Analysis_design_version_relationship
  SUBTYPE OF (Analysis_assignment);
  SELF\Analysis_assignment.applied_to : Product_version;
END_ENTITY;

ENTITY Analysis_discipline_definition
  SUBTYPE OF (Product_view_definition);
  SELF\Product_view_definition.defined_version : Analysis_version;
END_ENTITY;

ENTITY Analysis_model
  SUBTYPE OF (Representation);
  SELF\Representation.context_of_items : Analysis_representation_context;
END_ENTITY;

ENTITY Analysis_representation_context
  SUBTYPE OF (Representation_context);
END_ENTITY;

ENTITY Analysis_version
  SUBTYPE OF (Product_version);
  SELF\Product_version.of_product : Analysis;
END_ENTITY;

ENTITY Analysis_version_relationship
  SUBTYPE OF (Product_version_relationship);
  SELF\Product_version_relationship.relating_version : Analysis_version;
  SELF\Product_version_relationship.related_version : Analysis_version;
END_ENTITY;

ENTITY Analysis_version_sequence
  SUBTYPE OF (Analysis_version_relationship);
DERIVE
  predecessor : Analysis_version := SELF\Analysis_version_relationship.relating_version;
  successor : Analysis_version := SELF\Analysis_version_relationship.related_version;
END_ENTITY;

ENTITY And_state_cause_effect_definition
  SUBTYPE OF (State_cause_effect_definition);
END_ENTITY;

ENTITY Applied_activity_assignment;
  assigned_activity : Activity;
  items : SET[1:?] OF activity_item;
  role : STRING;
END_ENTITY;

ENTITY Applied_independent_property
  SUBTYPE OF (Assigned_property);
  base_independent_property : Independent_property;
DERIVE
  SELF\Assigned_property.name : STRING := base_independent_property.property_type;
END_ENTITY;

ENTITY Applied_information_usage_right;
  item : SET[1:?] OF information_usage_right_item;
  right_applied : Information_usage_right;
END_ENTITY;

ENTITY Applied_state_assignment;
  described_state : State;
  assigned_to : state_of_item;
  role : State_role;
END_ENTITY;

ENTITY Applied_state_definition_assignment;
  described_state_definition : State_definition;
  assigned_to : state_definition_of_item;
  role : State_definition_role;
END_ENTITY;

ENTITY Approval;
  status : Approval_status;
  purpose : STRING;
  planned_date : OPTIONAL date_or_date_time_select;
  actual_date : OPTIONAL date_or_date_time_select;
END_ENTITY;

ENTITY Approval_assignment;
  assigned_approval : Approval;
  items : SET[1:?] OF approval_item;
  role : OPTIONAL STRING;
END_ENTITY;

ENTITY Approval_relationship;
  relation_type : STRING;
  description : OPTIONAL STRING;
  relating_approval : Approval;
  related_approval : Approval;
END_ENTITY;

ENTITY Approval_status;
  status_name : STRING;
END_ENTITY;

ENTITY Approving_person_organization;
  person_organization : organization_or_person_in_organization_select;
  approval_date : OPTIONAL date_or_date_time_select;
  authorized_approval : Approval;
  role : OPTIONAL STRING;
END_ENTITY;

ENTITY Assigned_document_property
  SUBTYPE OF (Assigned_property);
  SELF\Assigned_property.described_element : document_property_item;
DERIVE
  SELF\Assigned_property.name : STRING := 'document property';
WHERE
  WR1: SIZEOF(['DECISION_SUPPORT_ARM_LF.DOCUMENT_DEFINITION', 'DECISION_SUPPORT_ARM_LF.FILE'] * TYPEOF(SELF\Assigned_property.described_element)) = 1;
END_ENTITY;

ENTITY Assigned_property;
  id : OPTIONAL STRING;
  name : STRING;
  description : OPTIONAL STRING;
  described_element : property_assignment_select;
END_ENTITY;

ENTITY Assumption;
  id : STRING;
  name : OPTIONAL STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Assumption_assignment;
  assumption : Assumption;
  description : OPTIONAL STRING;
  item : assumption_item;
  role : STRING;
END_ENTITY;

ENTITY Assumption_relationship;
  description : OPTIONAL STRING;
  role : STRING;
  relating_assumption : Assumption;
  related_assumption : Assumption;
END_ENTITY;

ENTITY Attribute_translation_assignment;
  considered_instance : string_select;
  considered_attribute : STRING;
  translation_text : STRING;
  translation_language : Language;
UNIQUE
  UR1: considered_instance, considered_attribute, translation_language;
END_ENTITY;

ENTITY Calendar_date;
  year_component : year_number;
  month_component : month_in_year_number;
  day_component : day_in_month_number;
END_ENTITY;

ENTITY Certification;
  name : STRING;
  description : OPTIONAL STRING;
  kind : STRING;
END_ENTITY;

ENTITY Certification_assignment;
  assigned_certification : Certification;
  items : SET[1:?] OF certification_item;
  role : STRING;
END_ENTITY;

ENTITY Class
  SUPERTYPE OF (ONEOF (Class_by_extension,
                       Class_by_intension));
  id : STRING;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Class_by_extension
  SUBTYPE OF (Class);
END_ENTITY;

ENTITY Class_by_intension
  SUBTYPE OF (Class);
END_ENTITY;

ENTITY Classification_assignment;
  assigned_class : Class;
  items : SET[1:?] OF classification_item;
  role : OPTIONAL STRING;
END_ENTITY;

ENTITY Collection
  SUBTYPE OF (Product);
END_ENTITY;

ENTITY Collection_assignment;
  collection : Collection_view_definition;
  is_assigned_to : collection_assignment_select;
END_ENTITY;

ENTITY Collection_membership;
  member : collection_member_select;
  of_collection : Collection_view_definition;
END_ENTITY;

ENTITY Collection_relationship
  SUBTYPE OF (Product_relationship);
  SELF\Product_relationship.relating_product : Collection;
  SELF\Product_relationship.related_product : Collection;
DERIVE
  related_collection : Collection := SELF\Product_relationship.related_product;
  relating_collection : Collection := SELF\Product_relationship.relating_product;
END_ENTITY;

ENTITY Collection_version
  SUBTYPE OF (Product_version);
  SELF\Product_version.of_product : Collection;
DERIVE
  of_collection : Collection := SELF\Product_version.of_product;
END_ENTITY;

ENTITY Collection_version_relationship
  SUBTYPE OF (Product_version_relationship);
  SELF\Product_version_relationship.relating_version : Collection_version;
  SELF\Product_version_relationship.related_version : Collection_version;
END_ENTITY;

ENTITY Collection_version_sequence_relationship
  SUBTYPE OF (Collection_version_relationship);
DERIVE
  predecessor : Collection_version := SELF\Product_version_relationship.relating_version;
  successor : Collection_version := SELF\Product_version_relationship.related_version;
END_ENTITY;

ENTITY Collection_view_definition
  SUBTYPE OF (Product_view_definition);
  SELF\Product_view_definition.defined_version : Collection_version;
END_ENTITY;

ENTITY Composition_of_state
  SUBTYPE OF (State_relationship);
DERIVE
  part : SET[1:?] OF State := SELF\State_relationship.related;
  whole : SET[1:?] OF State := SELF\State_relationship.relating;
END_ENTITY;

ENTITY Composition_of_state_definition
  SUBTYPE OF (State_definition_relationship);
DERIVE
  part : SET[1:?] OF State_definition := SELF\State_definition_relationship.related;
  whole : SET[1:?] OF State_definition := SELF\State_definition_relationship.relating;
END_ENTITY;

ENTITY Context_dependent_unit
  SUBTYPE OF (Unit);
WHERE
  WR1: EXISTS(SELF\Unit.name);
END_ENTITY;

ENTITY Contract;
  id : STRING;
  purpose : STRING;
  kind : STRING;
END_ENTITY;

ENTITY Contract_assignment;
  assigned_contract : Contract;
  items : SET[1:?] OF contract_item;
END_ENTITY;

ENTITY Contract_relationship;
  relating_contract : Contract;
  related_contract : Contract;
END_ENTITY;

ENTITY Conversion_based_unit
  SUBTYPE OF (Unit);
  conversion_factor : Value_with_unit;
WHERE
  WR1: EXISTS(SELF\Unit.name);
END_ENTITY;

ENTITY Date_or_date_time_assignment;
  assigned_date : date_or_date_time_select;
  role : STRING;
  items : SET[1:?] OF date_or_date_time_item;
END_ENTITY;

ENTITY Date_time;
  date_component : Calendar_date;
  time_component : Local_time;
END_ENTITY;

ENTITY Dated_effectivity
  SUBTYPE OF (Effectivity);
  start_bound : date_or_event;
  end_bound : OPTIONAL date_or_event;
END_ENTITY;

ENTITY Defined_state_relationship;
  name : STRING;
  description : OPTIONAL STRING;
  definitive_state : State_assertion;
  defined_state : State_assessment;
END_ENTITY;

ENTITY Derived_unit
  SUBTYPE OF (Unit);
  elements : SET[1:?] OF Derived_unit_element;
END_ENTITY;

ENTITY Derived_unit_element;
  base_unit : Unit;
  exponent : REAL;
END_ENTITY;

ENTITY Descriptive_document_property
  SUBTYPE OF (String_representation_item);
INVERSE
  valued_characteristic : SET[1:1] OF Document_property_representation FOR items;
END_ENTITY;

ENTITY Digital_document_definition
  SUBTYPE OF (Document_definition);
  files : SET[0:?] OF Digital_file;
END_ENTITY;

ENTITY Digital_file
  SUBTYPE OF (File);
END_ENTITY;

ENTITY Document
  SUBTYPE OF (Product);
END_ENTITY;

ENTITY Document_assignment;
  assigned_document : assigned_document_select;
  is_assigned_to : documented_element_select;
  role : STRING;
END_ENTITY;

ENTITY Document_definition
  SUPERTYPE OF (ONEOF (Digital_document_definition,
                       Physical_document_definition))
  SUBTYPE OF (Product_view_definition);
  SELF\Product_view_definition.defined_version : Document_version;
DERIVE
  associated_document_version : Document_version := SELF\Product_view_definition.defined_version;
  description : STRING := SELF\Product_view_definition.name;
END_ENTITY;

ENTITY Document_location_identification
  SUBTYPE OF (External_source_identification);
WHERE
  WR1: 'DECISION_SUPPORT_ARM_LF.DOCUMENT_DEFINITION' IN TYPEOF(SELF\External_source_identification.item);
END_ENTITY;

ENTITY Document_property_representation
  SUBTYPE OF (Representation);
  SELF\Representation.items : SET[1:?] OF descriptive_or_numerical;
WHERE
  WR1: SIZEOF(QUERY(pr <* USEDIN(SELF, 'DECISION_SUPPORT_ARM_LF.PROPERTY_DEFINITION_REPRESENTATION.REP') | 'DECISION_SUPPORT_ARM_LF.ASSIGNED_PROPERTY' IN TYPEOF(pr\Property_representation.property))) > 0;
  WR2: SELF\Representation.context_of_items.kind = 'document parameters';
  WR3: SIZEOF(QUERY(it1 <* SELF\Representation.items | SIZEOF(QUERY(it2 <* SELF\Representation.items | it1.name = it2.name)) > 1)) = 0;
END_ENTITY;

ENTITY Document_version
  SUBTYPE OF (Product_version);
  SELF\Product_version.of_product : Document;
END_ENTITY;

ENTITY Duration
  SUBTYPE OF (Value_with_unit);
WHERE
  WR1: 'DECISION_SUPPORT_ARM_LF.' + 'TIME_UNIT' IN TYPEOF(SELF\Value_with_unit.unit);
END_ENTITY;

ENTITY Effectivity
  SUPERTYPE OF (ONEOF (Serial_effectivity,
                       Dated_effectivity,
                       Lot_effectivity,
                       Time_interval_effectivity));
  id : STRING;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Effectivity_assignment;
  assigned_effectivity : Effectivity;
  role : STRING;
  items : SET[1:?] OF effectivity_item;
END_ENTITY;

ENTITY Effectivity_relationship;
  relation_type : STRING;
  description : OPTIONAL STRING;
  relating_effectivity : Effectivity;
  related_effectivity : Effectivity;
END_ENTITY;

ENTITY Electric_current_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Event;
  id : STRING;
  name : STRING;
  description : OPTIONAL STRING;
  actual_start_date : OPTIONAL date_or_date_time_select;
  planned_start_date : OPTIONAL date_or_date_time_select;
END_ENTITY;

ENTITY Event_assignment;
  assigned_event : Event;
  items : SET[1:?] OF event_item;
  role : STRING;
END_ENTITY;

ENTITY Event_relationship;
  relation_type : STRING;
  description : OPTIONAL STRING;
  relating_event : Event;
  related_event : Event;
END_ENTITY;

ENTITY Evidence;
  supports : evidence_support_item;
  items : SET[1:?] OF evidence_item;
END_ENTITY;

ENTITY External_analysis_model
  SUBTYPE OF (Analysis_model);
  external_file : Digital_file;
END_ENTITY;

ENTITY External_item_identification
  SUBTYPE OF (External_source_identification);
  external_id : STRING;
END_ENTITY;

ENTITY External_source;
  id : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY External_source_identification;
  source_id : STRING;
  source_type : STRING;
  item : external_identification_item;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY File
  ABSTRACT SUPERTYPE OF (ONEOF (Digital_file,
                                Hardcopy));
  id : STRING;
  version : OPTIONAL STRING;
  contained_data_type : OPTIONAL STRING;
END_ENTITY;

ENTITY File_location_identification
  SUBTYPE OF (External_item_identification);
WHERE
  WR1: 'DECISION_SUPPORT_ARM_LF.FILE' IN TYPEOF(SELF\External_source_identification.item);
END_ENTITY;

ENTITY Hardcopy
  SUBTYPE OF (File);
END_ENTITY;

ENTITY Identification_assignment;
  identifier : STRING;
  role : STRING;
  description : OPTIONAL STRING;
  items : SET[1:?] OF identification_item;
END_ENTITY;

ENTITY Identification_relationship;
  relating_identification_assignment : Identification_assignment;
  related_identification_assignment : Identification_assignment;
END_ENTITY;

ENTITY Independent_property;
  id : STRING;
  property_type : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Independent_property_relationship;
  relation_type : STRING;
  description : OPTIONAL STRING;
  relating : Independent_property;
  related : Independent_property;
END_ENTITY;

ENTITY Information_right;
  id : STRING;
  name : STRING;
  description : OPTIONAL STRING;
  restriction : OPTIONAL STRING;
END_ENTITY;

ENTITY Information_usage_right;
  id : STRING;
  name : STRING;
  comment : OPTIONAL STRING;
  grants_right : SET[1:?] OF Information_right;
END_ENTITY;

ENTITY Information_usage_right_relationship;
  relating : Information_usage_right;
  related : Information_usage_right;
  relation_type : STRING;
END_ENTITY;

ENTITY Item_assumed;
  assumption : Assumption;
  item : assumed_item;
END_ENTITY;

ENTITY Justification;
  id : STRING;
  name : OPTIONAL STRING;
  description : STRING;
  context_description : OPTIONAL STRING;
END_ENTITY;

ENTITY Justification_assignment;
  justification : Justification;
  description : OPTIONAL STRING;
  item : justification_item;
  role : STRING;
END_ENTITY;

ENTITY Justification_relationship;
  name : STRING;
  description : OPTIONAL STRING;
  relating_justification : Justification;
  related_justification : Justification;
END_ENTITY;

ENTITY Justification_support_assignment;
  justification : Justification;
  description : OPTIONAL STRING;
  support_item : justification_support_item;
  role : STRING;
END_ENTITY;

ENTITY Language;
  language_code : STRING;
  country_code : OPTIONAL STRING;
UNIQUE
  UR1: language_code;
END_ENTITY;

ENTITY Language_indication;
  considered_instance : string_select;
  considered_attribute : STRING;
  used_language : Language;
END_ENTITY;

ENTITY Length_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Local_time;
  hour_component : hour_in_day;
  minute_component : OPTIONAL minute_in_hour;
  second_component : OPTIONAL second_in_minute;
  zone : Time_offset;
END_ENTITY;

ENTITY Lot_effectivity
  SUBTYPE OF (Effectivity);
  lot_id : STRING;
  lot_size : Value_with_unit;
END_ENTITY;

ENTITY Luminous_intensity_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Mass_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Measure_item
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Representation_item);
WHERE
  WR1: SIZEOF(USEDIN(SELF, 'DECISION_SUPPORT_ARM_LF.REPRESENTATION.ITEMS')) > 0;
END_ENTITY;

ENTITY Numerical_document_property
  SUBTYPE OF (Numerical_item_with_unit);
INVERSE
  valued_characteristic : SET[1:1] OF Document_property_representation FOR items;
END_ENTITY;

ENTITY Numerical_item_with_global_unit
  SUBTYPE OF (Measure_item);
  value_component : measure_value;
WHERE
  WR1: SIZEOF(QUERY(pvr <* QUERY(r <* USEDIN(SELF, 'DECISION_SUPPORT_ARM_LF.REPRESENTATION.ITEMS') | 'DECISION_SUPPORT_ARM_LF.PROPERTY_VALUE_REPRESENTATION' IN TYPEOF(r)) | EXISTS(pvr.context_of_items.units))) > 0;
END_ENTITY;

ENTITY Numerical_item_with_unit
  SUBTYPE OF (Measure_item, Value_with_unit);
END_ENTITY;

ENTITY Numerical_representation_context
  SUBTYPE OF (Representation_context);
  units : OPTIONAL SET[1:?] OF Unit;
  accuracies : OPTIONAL SET[1:?] OF Uncertainty_with_unit;
END_ENTITY;

ENTITY Or_state_cause_effect_definition
  SUBTYPE OF (State_cause_effect_definition);
END_ENTITY;

ENTITY Organization;
  id : OPTIONAL STRING;
  name : STRING;
END_ENTITY;

ENTITY Organization_or_person_in_organization_assignment;
  assigned_entity : organization_or_person_in_organization_select;
  role : STRING;
  items : SET[1:?] OF organization_or_person_in_organization_item;
END_ENTITY;

ENTITY Organization_relationship;
  relation_type : STRING;
  description : OPTIONAL STRING;
  relating_organization : Organization;
  related_organization : Organization;
END_ENTITY;

ENTITY Partial_document_assignment
  SUBTYPE OF (Document_assignment);
  document_portion : STRING;
END_ENTITY;

ENTITY Person;
  last_name : STRING;
  first_name : OPTIONAL STRING;
  middle_names : OPTIONAL LIST[1:?] OF STRING;
  prefix_titles : OPTIONAL LIST[1:?] OF STRING;
  suffix_titles : OPTIONAL LIST[1:?] OF STRING;
END_ENTITY;

ENTITY Person_in_organization;
  concerned_person : Person;
  containing_organization : Organization;
  role : STRING;
END_ENTITY;

ENTITY Physical_document_definition
  SUBTYPE OF (Document_definition);
  components : SET[0:?] OF Hardcopy;
END_ENTITY;

ENTITY Plane_angle_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Product;
  id : STRING;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Product_relationship;
  relation_type : STRING;
  description : OPTIONAL STRING;
  relating_product : Product;
  related_product : Product;
END_ENTITY;

ENTITY Product_version;
  id : STRING;
  description : OPTIONAL STRING;
  of_product : Product;
END_ENTITY;

ENTITY Product_version_relationship;
  relation_type : OPTIONAL STRING;
  description : OPTIONAL STRING;
  relating_version : Product_version;
  related_version : Product_version;
WHERE
  WR1: relating_version :<>: related_version;
  WR2: EXISTS(relation_type) OR (TYPEOF(SELF\Product_version_relationship) <> TYPEOF(SELF));
END_ENTITY;

ENTITY Product_view_definition;
  id : OPTIONAL STRING;
  name : OPTIONAL STRING;
  additional_characterization : OPTIONAL STRING;
  initial_context : View_definition_context;
  additional_contexts : SET[0:?] OF View_definition_context;
  defined_version : Product_version;
WHERE
  WR1: NOT (initial_context IN additional_contexts);
  WR2: EXISTS(id) OR (TYPEOF(SELF\Product_view_definition) <> TYPEOF(SELF));
END_ENTITY;

ENTITY Project;
  id : STRING;
  name : STRING;
  description : OPTIONAL STRING;
  responsible_organizations : SET[0:?] OF Organization;
  planned_start_date : OPTIONAL date_or_event;
  planned_end_date : OPTIONAL date_or_event;
  actual_start_date : OPTIONAL date_or_date_time_select;
  actual_end_date : OPTIONAL date_or_date_time_select;
END_ENTITY;

ENTITY Project_assignment;
  assigned_project : Project;
  role : STRING;
  items : SET[1:?] OF project_item;
END_ENTITY;

ENTITY Project_relationship;
  relation_type : STRING;
  description : OPTIONAL STRING;
  relating_project : Project;
  related_project : Project;
END_ENTITY;

ENTITY Property_definition_representation
  ABSTRACT SUPERTYPE ;
  description : OPTIONAL STRING;
  definition : represented_definition;
  rep : Representation;
  role : OPTIONAL STRING;
END_ENTITY;

ENTITY Property_representation
  SUBTYPE OF (Property_definition_representation);
  SELF\Property_definition_representation.definition : Assigned_property;
DERIVE
  property : Assigned_property := SELF\Property_definition_representation.definition;
END_ENTITY;

ENTITY Property_value_representation
  SUBTYPE OF (Representation);
  SELF\Representation.context_of_items : Numerical_representation_context;
END_ENTITY;

ENTITY Ratio_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Relative_event
  SUBTYPE OF (Event);
  base_event : Event;
  offset : Duration;
END_ENTITY;

ENTITY Representation;
  id : OPTIONAL identifier;
  name : OPTIONAL label;
  description : OPTIONAL text;
  context_of_items : Representation_context;
  items : SET[1:?] OF Representation_item;
WHERE
  WR1: EXISTS(name) OR (TYPEOF(SELF\Representation) <> TYPEOF(SELF));
END_ENTITY;

ENTITY Representation_context;
  id : identifier;
  kind : text;
INVERSE
  representations_in_context : SET[1:?] OF Representation FOR context_of_items;
END_ENTITY;

ENTITY Representation_item
  ABSTRACT SUPERTYPE ;
  name : OPTIONAL label;
END_ENTITY;

ENTITY Representation_proxy_item
  SUBTYPE OF (Representation_item);
  item : representation_proxy_select;
END_ENTITY;

ENTITY Representation_relationship;
  relation_type : OPTIONAL label;
  description : OPTIONAL text;
  rep_1 : Representation;
  rep_2 : Representation;
WHERE
  WR1: EXISTS(relation_type) OR (TYPEOF(SELF\Representation_relationship) <> TYPEOF(SELF));
  WR2: EXISTS(description) OR (TYPEOF(SELF\Representation_relationship) <> TYPEOF(SELF));
END_ENTITY;

ENTITY Requirement
  SUBTYPE OF (Product);
END_ENTITY;

ENTITY Requirement_assignment;
  id : STRING;
  description : OPTIONAL STRING;
  assigned_requirement : Requirement_view_definition;
  assigned_to : requirement_assignment_item;
END_ENTITY;

ENTITY Requirement_collection_relationship
  SUBTYPE OF (Requirement_view_definition_relationship);
DERIVE
  collection : Requirement_view_definition := SELF\Requirement_view_definition_relationship.primary;
  member : Requirement_view_definition := SELF\Requirement_view_definition_relationship.secondary;
END_ENTITY;

ENTITY Requirement_satisfied_by;
  id : STRING;
  description : OPTIONAL STRING;
  satisfied_by : requirement_satisfaction_item;
  satisfied_requirement : Requirement_view_definition;
  related_assignment : OPTIONAL Requirement_assignment;
END_ENTITY;

ENTITY Requirement_source;
  id : STRING;
  description : OPTIONAL STRING;
  source : requirement_source_item;
  sourced_requirement : Requirement_view_definition;
END_ENTITY;

ENTITY Requirement_version
  SUBTYPE OF (Product_version);
  SELF\Product_version.of_product : Requirement;
END_ENTITY;

ENTITY Requirement_version_relationship
  SUBTYPE OF (Product_version_relationship);
  SELF\Product_version_relationship.relating_version : Requirement_version;
  SELF\Product_version_relationship.related_version : Requirement_version;
DERIVE
  predecessor : Requirement_version := SELF\Product_version_relationship.relating_version;
  successor : Requirement_version := SELF\Product_version_relationship.related_version;
END_ENTITY;

ENTITY Requirement_view_definition
  SUBTYPE OF (Product_view_definition);
  SELF\Product_view_definition.defined_version : Requirement_version;
END_ENTITY;

ENTITY Requirement_view_definition_relationship
  SUPERTYPE OF (ONEOF (Requirement_collection_relationship,
                       Tracing_relationship))
  SUBTYPE OF (View_definition_relationship);
  SELF\View_definition_relationship.relating_view : Requirement_view_definition;
  SELF\View_definition_relationship.related_view : Requirement_view_definition;
DERIVE
  primary : Requirement_view_definition := SELF\View_definition_relationship.relating_view;
  secondary : Requirement_view_definition := SELF\View_definition_relationship.related_view;
WHERE
  WR1: primary :<>: secondary;
END_ENTITY;

ENTITY Same_as_external_item;
  external_item_id : STRING;
  description : OPTIONAL STRING;
  role : STRING;
  external_source : External_source;
  items : SET[0:?] OF same_as_item;
END_ENTITY;

ENTITY Security_classification;
  classification_level : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Security_classification_assignment;
  classification : Security_classification;
  items : SET[1:?] OF security_classification_item;
END_ENTITY;

ENTITY Sequence_of_state
  SUBTYPE OF (State_relationship);
DERIVE
  predecessor : SET[1:?] OF State := SELF\State_relationship.related;
  successor : SET[1:?] OF State := SELF\State_relationship.relating;
END_ENTITY;

ENTITY Sequence_of_state_definition
  SUBTYPE OF (State_definition_relationship);
DERIVE
  predecessor : SET[1:?] OF State_definition := SELF\State_definition_relationship.related;
  successor : SET[1:?] OF State_definition := SELF\State_definition_relationship.relating;
END_ENTITY;

ENTITY Serial_effectivity
  SUBTYPE OF (Effectivity);
  start_id : STRING;
  end_id : OPTIONAL STRING;
END_ENTITY;

ENTITY Single_property_is_definition
  SUBTYPE OF (Assigned_property);
  SELF\Assigned_property.described_element : Product_view_definition;
UNIQUE
  UR1: SELF\Assigned_property.described_element;
END_ENTITY;

ENTITY Solid_angle_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY State
  SUPERTYPE OF (ONEOF (State_observed,
                       State_predicted));
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY State_assertion;
  name : STRING;
  description : OPTIONAL STRING;
  asserted_state : State;
  conformance_state : State_definition;
END_ENTITY;

ENTITY State_assessment;
  name : STRING;
  description : OPTIONAL STRING;
  assessed_state : State;
  comparable_state : State_definition;
END_ENTITY;

ENTITY State_cause_effect
  SUBTYPE OF (State_relationship);
DERIVE
  cause : SET[1:?] OF State := SELF\State_relationship.related;
  effect : SET[1:?] OF State := SELF\State_relationship.relating;
END_ENTITY;

ENTITY State_cause_effect_definition
  SUBTYPE OF (State_definition_relationship);
DERIVE
  cause : SET[1:?] OF State_definition := SELF\State_definition_relationship.related;
  effect : SET[1:?] OF State_definition := SELF\State_definition_relationship.relating;
END_ENTITY;

ENTITY State_complement_definition
  SUBTYPE OF (State_definition_relationship);
  set_2 : SET[1:?] OF State_definition;
DERIVE
  set_1 : SET[1:?] OF State_definition := SELF\State_definition_relationship.related;
  universe : SET[1:?] OF State_definition := SELF\State_definition_relationship.relating;
END_ENTITY;

ENTITY State_definition;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY State_definition_relationship;
  name : STRING;
  description : OPTIONAL STRING;
  relating : SET[1:?] OF State_definition;
  related : SET[1:?] OF State_definition;
END_ENTITY;

ENTITY State_definition_role;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY State_observed
  SUBTYPE OF (State);
END_ENTITY;

ENTITY State_predicted
  SUBTYPE OF (State);
END_ENTITY;

ENTITY State_predicted_to_observed
  SUBTYPE OF (State_relationship);
  SELF\State_relationship.relating : SET[1:?] OF State_observed;
  SELF\State_relationship.related : SET[1:?] OF State_predicted;
DERIVE
  observed_state : SET[1:?] OF State_observed := SELF\State_relationship.relating;
  predicted_state : SET[1:?] OF State_predicted := SELF\State_relationship.related;
END_ENTITY;

ENTITY State_proper_subset_definition
  SUBTYPE OF (State_definition_relationship);
DERIVE
  proper_subset : SET[1:?] OF State_definition := SELF\State_definition_relationship.related;
  proper_superset : SET[1:?] OF State_definition := SELF\State_definition_relationship.relating;
END_ENTITY;

ENTITY State_relationship;
  name : STRING;
  description : OPTIONAL STRING;
  relating : SET[1:?] OF State;
  related : SET[1:?] OF State;
END_ENTITY;

ENTITY State_role;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY State_subset_definition
  SUBTYPE OF (State_definition_relationship);
DERIVE
  subset : SET[1:?] OF State_definition := SELF\State_definition_relationship.related;
  superset : SET[1:?] OF State_definition := SELF\State_definition_relationship.relating;
END_ENTITY;

ENTITY State_symptom_definition
  SUBTYPE OF (State_definition_relationship);
DERIVE
  symptom_cause : SET[1:?] OF State_definition := SELF\State_definition_relationship.related;
  symptom_effect : SET[1:?] OF State_definition := SELF\State_definition_relationship.relating;
END_ENTITY;

ENTITY State_transition
  SUBTYPE OF (State_relationship);
DERIVE
  end_state : SET[1:?] OF State := SELF\State_relationship.relating;
  start_state : SET[1:?] OF State := SELF\State_relationship.related;
END_ENTITY;

ENTITY State_transition_definition
  SUBTYPE OF (State_definition_relationship);
DERIVE
  end_state : SET[1:?] OF State_definition := SELF\State_definition_relationship.relating;
  start_state : SET[1:?] OF State_definition := SELF\State_definition_relationship.related;
END_ENTITY;

ENTITY String_representation_item
  SUBTYPE OF (Representation_item);
  string_value : STRING;
END_ENTITY;

ENTITY Supplied_part_relationship
  SUBTYPE OF (Product_version_relationship);
WHERE
  WR1: SELF\Product_version_relationship.relation_type IN ['supplied item', 'supplied document'];
END_ENTITY;

ENTITY Thermodynamic_temperature_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Time_interval;
  id : STRING;
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Time_interval_effectivity
  SUBTYPE OF (Effectivity);
  effectivity_period : Time_interval;
END_ENTITY;

ENTITY Time_interval_relationship;
  relation_type : STRING;
  description : STRING;
  relating_time_interval : Time_interval;
  related_time_interval : Time_interval;
END_ENTITY;

ENTITY Time_interval_with_bounds
  SUBTYPE OF (Time_interval);
  primary_bound : OPTIONAL date_or_event;
  secondary_bound : OPTIONAL date_or_event;
  duration_from_primary_bound : OPTIONAL Duration;
WHERE
  WR1: NOT (EXISTS(secondary_bound) AND EXISTS(duration_from_primary_bound));
  WR2: EXISTS(primary_bound) OR EXISTS(secondary_bound);
END_ENTITY;

ENTITY Time_offset;
  hour_offset : INTEGER;
  minute_offset : OPTIONAL INTEGER;
  sense : offset_orientation;
DERIVE
  actual_minute_offset : INTEGER := NVL(minute_offset, 0);
WHERE
  WR1: {0 <= hour_offset < 24};
  WR2: {0 <= actual_minute_offset <= 59};
  WR3: NOT (((hour_offset <> 0) OR (actual_minute_offset <> 0)) AND (sense = exact));
END_ENTITY;

ENTITY Time_unit
  SUBTYPE OF (Unit);
END_ENTITY;

ENTITY Tracing_relationship
  SUBTYPE OF (Requirement_view_definition_relationship);
DERIVE
  traces_from : Requirement_view_definition := SELF\Requirement_view_definition_relationship.primary;
  traces_to : Requirement_view_definition := SELF\Requirement_view_definition_relationship.secondary;
END_ENTITY;

ENTITY Uncertainty_with_unit
  SUBTYPE OF (Value_with_unit);
  name : STRING;
  description : OPTIONAL STRING;
END_ENTITY;

ENTITY Unit
  SUPERTYPE OF (ONEOF (Amount_of_substance_unit,
                       Electric_current_unit,
                       Length_unit,
                       Luminous_intensity_unit,
                       Mass_unit,
                       Plane_angle_unit,
                       Ratio_unit,
                       Solid_angle_unit,
                       Thermodynamic_temperature_unit,
                       Time_unit));
  name : STRING;
  si_unit : BOOLEAN;
END_ENTITY;

ENTITY Validation;
  validates : validation_item;
INVERSE
  validated_by : SET[0:?] OF Evidence FOR supports;
END_ENTITY;

ENTITY Value_with_unit;
  unit : Unit;
  value_component : measure_value;
END_ENTITY;

ENTITY Verification;
  verifies : Requirement_satisfied_by;
INVERSE
  verified_by : SET[0:?] OF Evidence FOR supports;
END_ENTITY;

ENTITY Verification_relationship;
  relating : Verification;
  related : Verification;
END_ENTITY;

ENTITY View_definition_context;
  application_domain : STRING;
  life_cycle_stage : STRING;
  description : OPTIONAL STRING;
WHERE
  WR1: (SIZEOF(USEDIN(SELF, 'DECISION_SUPPORT_ARM_LF.' + 'PRODUCT_VIEW_DEFINITION.INITIAL_CONTEXT')) > 0) OR (SIZEOF(USEDIN(SELF, 'DECISION_SUPPORT_ARM_LF.' + 'PRODUCT_VIEW_DEFINITION.ADDITIONAL_CONTEXTS')) > 0);
END_ENTITY;

ENTITY View_definition_relationship;
  id : OPTIONAL STRING;
  relation_type : OPTIONAL STRING;
  description : OPTIONAL STRING;
  relating_view : Product_view_definition;
  related_view : Product_view_definition;
END_ENTITY;

ENTITY View_definition_usage
  SUBTYPE OF (View_definition_relationship);
END_ENTITY;

ENTITY Xor_state_cause_effect_definition
  SUBTYPE OF (State_cause_effect_definition);
END_ENTITY;

RULE document_definition_constraint FOR
(Product_view_definition);
WHERE
  WR1: SIZEOF(QUERY(dd <* Product_view_definition | (NOT ('DECISION_SUPPORT_ARM_LF.' + 'DOCUMENT_DEFINITION' IN TYPEOF(dd))) AND ('DECISION_SUPPORT_ARM_LF.' + 'DOCUMENT_VERSION' IN TYPEOF(dd.defined_version)))) = 0;
 END_RULE;

RULE document_version_constraint FOR
(Product_version);
WHERE
  WR1: SIZEOF(QUERY(pv <* Product_version | (NOT ('DECISION_SUPPORT_ARM_LF.' + 'DOCUMENT_VERSION' IN TYPEOF(pv))) AND ('DECISION_SUPPORT_ARM_LF.' + 'DOCUMENT' IN TYPEOF(pv.of_product)))) = 0;
 END_RULE;

END_SCHEMA;  -- Decision_support_arm_LF


© ISO 2011 — All rights reserved