// ===================================================================
// Title:       Core Elements 2.7
// Filename:    Core27_CoreElements.mof
// Version:     2.7.0
// Release:     Final
// Date:        04/23/03
// ===================================================================
// Copyright 1998-2003 Distributed Management Task Force, Inc. (DMTF).
// All rights reserved.  
// DMTF is a not-for-profit association of industry members dedicated 
// to promoting enterprise and systems management and interoperability. 
// DMTF specifications and documents may be reproduced for uses
// consistent with this purpose by members and non-members, 
// provided that correct attribution is given. 
// As DMTF specifications may be revised from time to time, 
// the particular version and release date should always be noted.
//
// Implementation of certain elements of this standard or proposed 
// standard may be subject to third party patent rights, including 
// provisional patent rights (herein "patent rights"). DMTF makes 
// no representations to users of the standard as to the existence 
// of such rights, and is not responsible to recognize, disclose, or
// identify any or all such third party patent right, owners or 
// claimants, nor for any incomplete or inaccurate identification or 
// disclosure of such rights, owners or claimants. DMTF shall have no 
// liability to any party, in any manner or circumstance, under any 
// legal theory whatsoever, for failure to recognize, disclose, or 
// identify any such third party patent rights, or for such party's
// reliance on the standard or incorporation thereof in its product, 
// protocols or testing procedures. DMTF shall have no liability to 
// any party implementing such standard, whether such implementation 
// is foreseeable or not, nor to any patent owner or claimant, and shall 
// have no liability or responsibility for costs or losses incurred if 
// a standard is withdrawn or modified after publication, and shall be
// indemnified and held harmless by any party implementing the 
// standard from any and all claims of infringement by a patent owner 
// for such implementations.
//
// For information about patents held by third-parties which have 
// notified the DMTF that, in their opinion, such patent may relate to 
// or impact implementations of DMTF standards, visit 
// http://www.dmtf.org/about/policies/disclosures.php.
// ===================================================================
// Description: The Core Model defines basic management concepts. 
//              This file defines the concepts for the top of the CIM
//              object hierarchies (ManagedElement, ManagedSystemElement,
//              LogicalElement, Systems, Services, etc.) and the 'top'
//              associations (Dependency, Component, 
//              LogicalIdentity, ...).
//
//              The object classes below are listed in an order that
//              avoids forward references. Required objects, defined 
//              by other working groups, are omitted.
// ==================================================================
// Change Log for v2.7 Final
// CR961 - Rename EnabledLogicalElement. xxxStatus properties to be
//         State.
//       - Update description of xxxState properties to reflect the
//         expected behavior of the state values.
//       - Change references to EnabledStatus and RequestedStatus to 
//         EnabledState and RequestedState in the Service.
//            StartService()
//            StopService()  
// CR966 - Remove the Terminal qualifier from ConcreteDependency,
//         ConcreteComponent, and ConcreteIdentity associations and
//         add text to describe the intent of the original placement
// CR968 - Remove the Experimental qualifier
// CR993 - Change property name and description of 
//            ManagedSystemElement.OtherStatusDescription
// CR1009 - Add ServiceAccessURI class
//
// Change Log for v2.7
// CR641 - Add ConcreteDependency
// CR643 - Promote Component to ManagedElement, and add 
//         ConcreteComponent
// CR660 - Add RemoteServiceAccessPoint and RemotePort
// CR663 - Update the Description of ActiveConnection and some of 
//         its properties.  Deprecate the properties, TrafficType 
//         and OtherTrafficDescription 
// CR670 - Promote LogicalIdentity to ManagedElement, and add
//         ConcreteIdentity
// CR671 - Deprecate ProvidesServiceToElement
//       - Add ServiceAvailableToElement
//       - Update description for ServiceServiceDependency
// CR672 - Update description for SystemComponent to clarify its use
// CR677 - Add the array property OperationalStatus & OtherStatus
//         Description, and deprecate the existing Status property of
//         ManagedSystemElement
//       - Deprecate StartMode in Service
// CR717 - Clarify description of System.Roles
// CR747 - Add the Write Qualifier and update description of System.
//         Roles
// CR751 - Promote ActiveConnection from ProtocolEndpoint to 
//         ServiceAccessPoint
// CR757 - Add EnabledLogicalElement
//       - Change subclass of System, Service, and ServiceAccessPoint
//         from LogicalElement to EnabledLogicalElement
//       - Update the descriptions to Service.StartService() and
//         Service.StopService() to explain the overlap with 
//         RequestedStatus
//       - Update the deprecation of Service.StartMode to 
//         EnabledDefault
// CR758 - Add ElementName to ManagedElement
// CR764 - Add ServiceAffectsElement
// CR779 - Extend ManagedSystemElement.OperationalStatus to include
//         "Completed"
// CR804 - Update the enumeration for ProtocolEndpoint.ProtocolType
// CR833 - Extend EnabledLogicalElement.EnabledStatus & .Requested
//         Status to include "In Test" and "Test" respectively
// CR834 - Extend ManagedSystemElement.OperationalStatus to include 
//         "Aborted", "Dormant", and "Supported Entity in Error"
// CR844 - Add PrimaryOwnerName and PrimaryOwnerContact to Service;
//         Add Write qualifier to the same properties in System
// CR894 - Clarify the description for System.
// CR898 - Extend MaxLen qualifier on ManagedSystemElement.Name 
//         from 256 to 1024 (to match subclassing requriements)
// ==================================================================

#pragma locale ("en_US")


// ==================================================================
// ManagedElement
// ================================================================== 
[Abstract, Version ("2.7.0"), Description (
    "ManagedElement is an abstract class that provides a common "  
    "superclass (or top of the inheritance tree) for the "
    "non-association classes in the CIM Schema.") ]
class CIM_ManagedElement {  

    [MaxLen (64), Description (  
        "The Caption property is a short textual description (one-"    
        "line string) of the object.") ]   
    string Caption;  
    
    [Description (  
        "The Description property provides a textual description of "
        "the object.") ]   
    string Description;    
      
    [Description (  
        "  A user-friendly name for the object. This property allows "
        "each instance to define a user-friendly name IN ADDITION TO its "
        "key properties/identity data, and description information. \n"
        "  Note that ManagedSystemElement's Name property is also defined "
        "as a user-friendly name. But, it is often subclassed to be a "
        "Key. It is not reasonable that the same property can convey "
        "both identity and a user friendly name, without inconsistencies. "
        "Where Name exists and is not a Key (such as for instances of "
        "LogicalDevice), the same information MAY be present in both "
        "the Name and ElementName properties.") ]
    string ElementName;
};
     

// ==================================================================
// Dependency   
// ==================================================================
[Association, Abstract, Version ("2.6.0"), Description (   
    "CIM_Dependency is a generic association used to establish "   
    "dependency relationships between ManagedElements.") ]    
class CIM_Dependency {   

    [Key, Description (   
        "Antecedent represents the independent object in this "   
        "association.") ]    
    CIM_ManagedElement REF Antecedent;   
    
    [Key, Description (   
        "Dependent represents the object dependent on the "   
        "Antecedent.") ]    
    CIM_ManagedElement REF Dependent;   
};   
 
                 
// ==================================================================
// ConcreteDependency   
// ==================================================================
[Association, Version ("2.7.0"), Description (
    "  CIM_ConcreteDependency is a generic association used to "
    "establish dependency relationships between ManagedElements. It "
    "is defined as a concrete subclass of the abstract "
    "CIM_Dependency class, to be used in place of many specific "
    "subclasses of Dependency that add no semantics - "
    "i.e., that do not clarify the type of dependency, update "
    "cardinalities, or add/remove qualifiers. Note that when "
    "defining additional semantics for Dependency that this class "
    "MUST NOT be subclassed. Specific semantics continue to "
    "be defined as subclasses of the abstract CIM_Dependency. "
    "ConcreteDependency is limited in its use as a concrete form of "
    "a general dependency. \n"
    "\n"
    "  It was deemed more prudent to create this concrete subclass "
    "than to change Dependency from an abstract to a concrete class. "
    "Dependency already had multiple abstract subclasses in the CIM "
    "Schema, and wider industry usage and impact could not be "
    "anticipated.") ]    
class CIM_ConcreteDependency : CIM_Dependency {   
 
    [Override ("Antecedent"), Description (   
        "Antecedent represents the independent object in this "   
        "association.") ]    
    CIM_ManagedElement REF Antecedent;   
 
    [Override ("Dependent"), Description (   
        "Dependent represents the object dependent on the "   
        "Antecedent.") ]    
    CIM_ManagedElement REF Dependent;   
};

// ==================================================================
// Component
// ==================================================================
[Association, Abstract, Aggregation, Version ("2.7.0"), Description (
    "CIM_Component is a generic association used to establish "
    "'part of' relationships between Managed Elements. For "
    "example, it could be used to define the components or parts of "
    "a System.") ] 
class CIM_Component {

    [Aggregate, Key, Description (
        "The parent element in the association.") ] 
    CIM_ManagedElement REF GroupComponent;
    
    [Key, Description (
        "The child element in the association.") ] 
    CIM_ManagedElement REF PartComponent;
};

     
// ==================================================================
// ConcreteComponent
// ==================================================================
[Association, Aggregation, 
    Version ("2.7.0"), Description (   
    "  CIM_ConcreteComponent is a generic association used to "
    "establish 'part of' relationships between ManagedElements. It "
    "is defined as a concrete subclass of the abstract "
    "CIM_Component class, to be used in place of many "
    "specific subclasses of Component that add no semantics - "
    "i.e., that do not clarify the type of composition, update "
    "cardinalities, or add/remove qualifiers. Note that when "
    "defining additional semantics for Component that this "
    "class MUST NOT be subclassed. Specific semantics "
    "continue to be defined as subclasses of the abstract "
    "CIM_Component.  ConcreteComponent is limited in its use "
    "as a concrete form of a general composition. \n"
    "\n"
    "  It was deemed more prudent to create this concrete subclass "
    "than to change Component from an abstract to a concrete class. "
    "Industry usage and impact could not be anticipated.") ]    
class CIM_ConcreteComponent : CIM_Component {

    [Aggregate, Override ("GroupComponent"), Description (
        "The parent element in the association.") ] 
    CIM_ManagedElement REF GroupComponent;

    [Override ("PartComponent"), Description (
        "The child element in the association.") ] 
    CIM_ManagedElement REF PartComponent;
};     


// ==================================================================
// LogicalIdentity
// ==================================================================
[Association, Abstract, Version ("2.7.0"), Description (
    "  CIM_LogicalIdentity is an abstract and generic association, "
    "indicating that two ManagedElements represent different "
    "aspects of the same underlying entity. This relationship "
    "conveys what could be defined with multiple inheritance.  "
    "In most scenarios, the Identity relationship is "
    "determined by the equivalence of Keys or some other "
    "identifying properties of the related Elements. \n\n"
    "  One of the scenarios where this relationship is reasonable "
    "is to represent that a LogicalDevice is both a 'bus' entity and "
    "a 'functional' entity. For example, a Device could be both a "
    "USB (bus) and a Keyboard (functional) entity.") ]
class CIM_LogicalIdentity {
      
    [Key, Description (
        "SystemElement represents one aspect of the Managed"
        "Element.  The use of 'System' in the role name does not "
        "limit the scope of the association. The role name was "
        "defined in the original association, where the "
        "referenced elements were limited to LogicalElements. "
        "Since that time, it has been found valuable to instantiate "
        "these types of relationships for ManagedElements, such as "
        "Collections. So, the referenced elements of the association "
        "were redefined to be ManagedElements. Unfortunately, the "
        "role name could not be changed without deprecating the "
        "entire association. This was not deemed necessary just to "
        "correct the role name.") ]
    CIM_ManagedElement REF SystemElement;
   
    [Key, Description (
        "SameElement represents an alternate aspect of the "
        "ManagedElement.") ]
    CIM_ManagedElement REF SameElement;
};


// ==================================================================     
// ConcreteIdentity
// ==================================================================     
[Association, Version ("2.7.0"), Description (
    "  CIM_ConcreteIdentity associates two elements representing "
    "different aspects of the same underlying entity. It is "
    "defined as a concrete subclass of the abstract "
    "CIM_LogicalIdentity class, to be used in place of many specific "
    "subclasses of LogicalIdentity that add no semantics - "
    "i.e., that do not clarify the type of identity, update "
    "cardinalities, or add/remove qualifiers. Note -that when  "
    "defining additional semantics for LogicalIdentity that this class "
    "should not be subclassed. Specifc semantics continue to be "
    "defined as subclasses of the abstract CIM_LogicalIdentity. "
    "ConcreteIdentity is limited in its use as a concrete form of "
    "a general identity relationship. \n"
    "\n"
    "  It was deemed more prudent to create this concrete subclass "
    "than to change LogicalIdentity from an abstract to a concrete "
    "class. LogicalIdentity already had multiple abstract subclasses "
    "in the CIM Schema, and wider industry usage and impact could "
    "not be anticipated.") ]
class CIM_ConcreteIdentity : CIM_LogicalIdentity {
     
    [Override ("SystemElement"), Description (
        "One aspect of the ManagedElement.  The use of 'System' "
        "in the name does not limit the scope of the association. "
        "This is an artifact of the original definition of the "
        "association.") ]
    CIM_ManagedElement REF SystemElement;
     
    [Override ("SameElement"), Description (
        "Another aspect of the ManagedElement.") ]
    CIM_ManagedElement REF SameElement;
};


// ================================================================== 
// ManagedSystemElement
// ==================================================================
[Abstract, Version ("2.7.0"), Description (
    "CIM_ManagedSystemElement is the base class for the System "
    "Element hierarchy. Membership Criteria: Any distinguishable "
    "component of a System is a candidate for inclusion in this "
    "class. Examples: software components, such as files; and "
    "devices, such as disk drives and controllers, and physical "
    "components such as chips and cards.") ] 
class CIM_ManagedSystemElement : CIM_ManagedElement {

    [Description (
        "A datetime value indicating when the object was installed. "
        "A lack of a value does not indicate that the object is not "
        "installed."), 
        MappingStrings {"MIF.DMTF|ComponentID|001.5"} ] 
    datetime InstallDate;
    
    [MaxLen (1024), Description (
        "The Name property defines the label by which the object is "
        "known. When subclassed, the Name property can be overridden "
        "to be a Key property.") ] 
    string Name;
   
    [Description ( 
        "   Indicates the current status(es) of the element. "
        "Various health and operational statuses are "
        "defined. Many of the enumeration's values are self-"
        "explanatory.  However, a few are not and are described "
        "in more detail. \n"
        "  \"Stressed\" indicates that the element is functioning, "
        "but needs attention. Examples of \"Stressed\" states are "
        "overload, overheated, etc. \n"
        "  \"Predictive Failure\" indicates that an element is "
        "functioning nominally but predicting a failure in the "
        "near future. \n"
        "  \"In Service\" describes an element being configured, "
        "maintained, cleaned, or otherwise administered. \n"
        "  \"No Contact\" indicates that the monitoring system "
        "has knowledge of this element, but has never been able to "
        "establish communications with it. \n"
        "  \"Lost Communication\" indicates that the ManagedSystem"
        "Element is known to exist and has been contacted "
        "successfully in the past, but is currently unreachable. \n"
        "  \"Stopped\" and \"Aborted\" are similar, although the "
        "former implies a clean and orderly stop, while the latter "
        "implies an abrupt stop where the element's state and "
        "configuration may need to be updated. \n"
        "\"Dormant\" indicates that the element is inactive or "
        "quiesced. \n"
        "  \"Supporting Entity in Error\" describes that this "
        "element may be \"OK\" but that another element, on which it "
        "is dependent, is in error. An example is a network service "
        "or endpoint that cannot function due to lower layer "
        "networking problems. \n"
        "\"Completed\" indicates the element has completed its "
        "operation.  This value should be combined with either OK, "
        "Error, or Degraded so that a client can till if the complete "
        "operation passed (Completed with OK), and failure (Completed "
        "with Error).  Completed with Degraded would imply the "
        "operation finished, but did not complete OK or report an "
        "error. \n"
        "  OperationalStatus replaces the Status property on "
        "ManagedSystemElement to provide a consistent approach to "
        "enumerations, to address implementation needs for an "
        "array property, and to provide a migration path from today's "
        "environment to the future. This change was not made earlier "
        "since it required the DEPRECATED qualifier. Due to the "
        "widespread use of the existing Status property in "
        "management applications, it is strongly recommended that "
        "providers/instrumentation provide BOTH the Status and "
        "OperationalStatus properties. As always, Status (since it "
        "is single-valued) provides the primary status of the "
        "element."),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", 
            "9", "10", "11", "12", "13", "14", "15", "16", "17"}, 
        Values {"Unknown", "Other", "OK", "Degraded", "Stressed",
            "Predictive Failure", "Error", "Non-Recoverable Error", 
            "Starting", "Stopping", "Stopped", "In Service", 
            "No Contact", "Lost Communication", "Aborted", 
            "Dormant", "Supporting Entity in Error", "Completed"}, 
        ArrayType ("Indexed"),
        ModelCorrespondence {
            "CIM_ManagedSystemElement.StatusDescriptions"} ] 
    uint16 OperationalStatus[];
    
    [Description (
        "Strings describing the various OperationalStatus "
        "array values. For example, if \"Stopping\" is the value "
        "assigned to OperationalStatus, then this property may "
        "contain an explanation as to why an object is being "
        "stopped. Note that entries in this array are correlated "
        "with those at the same array index in OperationalStatus."),
        ArrayType ("Indexed"), 
        ModelCorrespondence {
            "CIM_ManagedSystemElement.OperationalStatus"} ]
    string StatusDescriptions[];
    
    [MaxLen (10), 
        Deprecated {"CIM_ManagedSystemElement.OperationalStatus"},
        Description ( 
            "A string indicating the current status of the object. " 
            "Various operational and non-operational statuses are " 
            "defined. This property is deprecated in lieu of " 
            "OperationalStatus, which includes the same semantics "
            "in its enumeration. This change is made for 3 reasons: "
            "1) Status is more correctly defined as an array. "
            "This overcomes the limitation of describing status via a "
            "single value, when it is really a multi-valued property " 
            "(for example, an element may be OK AND Stopped. 2) A "
            "MaxLen of 10 is too restrictive and leads to unclear "
            "enumerated values. And, 3) The change to a uint16 data "
            "type was discussed when CIM V2.0 was defined. However, "
            "existing V1.0 implementations used the string property "
            "and did not want to modify their code. Therefore, Status "
            "was grandfathered into the Schema. Use of the Deprecated "
            "qualifier allows the maintenance of the existing "
            "property, but also permits an improved definition using "
            "OperationalStatus."), 
       ValueMap {"OK", "Error", "Degraded", "Unknown", "Pred Fail", 
                 "Starting", "Stopping", "Service", "Stressed", 
                 "NonRecover", "No Contact", "Lost Comm", "Stopped"} ] 
   string Status; 
};


// ==================================================================
// LogicalElement
// ==================================================================
[Abstract, Version ("2.6.0"), Description (
    "CIM_LogicalElement is a base class for all the components of "
    "a System that represent abstract system components, such "
    "as Files, Processes, or LogicalDevices.") ] 
class CIM_LogicalElement : CIM_ManagedSystemElement {
};


// ==================================================================
// EnabledLogicalElement
// ==================================================================
[Abstract, Version ("2.7.0"), Description (
    "This class extends LogicalElement to abstract the concept of an "
    "element that is enabled and disabled, such as a LogicalDevice or "
    "a ServiceAccessPoint.") ]
class CIM_EnabledLogicalElement : CIM_LogicalElement {

    [Description (
        "EnabledState is an integer enumeration that indicates the "
        "enabled/disabled states of an element. It can also indicate "
        "the transitions between these requested states. For "
        "example, shutting down (value = 4) and starting "
        "(value=8) are transient states between enabled and disabled. "
        "The following text briefly summarizes the various "
        "enabled/disabled states: \n"
        "Enabled (2) indicates that the element is/could be executing "
        "commands, will process any queued commands, and queues new "
        "requests. \n"
        "Disabled (3) indicates that the element will not execute "
        "commands and will drop any new requests. \n"
        "Shutting Down (4) indicates that the element is in the process "
        "of going to a Disabled state. \n"
        "Not Applicable (5) indicates the element doesn't support being "
        "enabled/disabled. \n"
        "Enabled but Offline (6) indicates that the element may be "
        "completing commands, and will drop any new requests. \n"
        "Test (7) indicates that the element is in a test state. \n"
        "Deferred (8) indicates that the element may be completing "
        "commands, but will queue any new requests. \n"
        "Quiesce (9) indicates that the element is enabled but in a "
        "restricted mode. The element's behavior is similar to the "
        "Enabled state, but it only processes a restricted set of "
        "commands. All other requests are queued. \n"
        "Starting (10) indicates that the element is in the process of "
        "going to an Enabled state.  New requests are queued. \n"),
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
                        "11..32767", "32768..65535" }, 
        Values {"Unknown", "Other", "Enabled", "Disabled", 
            "Shutting Down", "Not Applicable", "Enabled but Offline",
            "In Test", "Deferred", "Quiesce", "Starting",
            "DMTF Reserved", "Vendor Reserved" },
        ModelCorrespondence {
            "CIM_EnabledLogicalElement.OtherEnabledState"} ]
    uint16 EnabledState = 5;
    
    [Description (
        "A string describing the element's enabled/disabled state when "
        "the EnabledState property is set to 1 (\"Other\"). This "
        "property MUST be set to NULL when EnabledState "
        "is any value other than 1."),
        ModelCorrespondence {"CIM_EnabledLogicalElement.EnabledState"} ]
    string OtherEnabledState;
 
    [Description (
        "RequestedState is an integer enumeration indicating "
        "the last requested or desired state for the element. "
        "The actual state of the element is represented by EnabledState. " 
        "This property is provided to compare the last requested and "
        "current enabled/disabled states. Note that when "
        "EnabledState is set to 5 (\"Not Applicable\"), "
        "then this property has no meaning. By default, "
        "the element's RequestedState is 5 (\"No Change\"). Refer "
        "to the EnabledState's property Description for explanations "
        "of the values in the RequestedState enumeration. \n" 
        "\n"
        "This property is set as the result of a method invocation "
        "(such as Start or StopService on CIM_Service), or may be "
        "overridden and defined as WRITEable in a subclass. The method "
        "approach is considered superior to a WRITEable property, "
        "since it allows an explicit invocation of the operation and "
        "the return of a result code."),
        ModelCorrespondence  {"CIM_EnabledLogicalElement.EnabledState"},
        ValueMap {"2", "3", "4", "5", "6", "7", "8", "9",
                        "10..32767", "32768..65535" },  
        Values {"Enabled", "Disabled", "Shut Down", "No Change",
            "Offline", "Test", "Deferred", "Quiesce",
            "DMTF Reserved", "Vendor Reserved"} ]
    uint16 RequestedState = 5;
 
    [Write, Description (
        "An enumerated value indicating an administrator's "
        "default/startup configuration for an element's Enabled"
        "State. By default, the element is \"Enabled\" (value=2)."), 
        ValueMap {"2", "3", "5", "6", "7", "8..32767", 
                        "32768..65535"}, 
        Values {"Enabled", "Disabled", "Not Applicable", 
            "Enabled but Offline", "No Default",
            "DMTF Reserved", "Vendor Reserved"} ] 
    uint16 EnabledDefault = 2;
};

     
// ==================================================================
// Synchrononized
// ==================================================================
[Association, Version ("2.6.0"), Description (
    "Indicates that two LogicalElements were aligned or made to "
    "be equivalent at the specified point in time. If the boolean "
    "property SyncMaintained is TRUE, then synchronization "
    "of the Elements is preserved. Both like and unlike objects "
    "may be synchronized. For example, two WatchDog timers may be "
    "aligned, or the contents of a LogicalFile may be synchronized "
    "with the contents of a StorageExtent.") ]
class CIM_Synchronized {
      
    [Key, Description (
        "SystemElement represents one LogicalElement that is "
        "synchronized with the entity referenced as SyncedElement.") ]
    CIM_LogicalElement REF SystemElement;
    
    [Key, Description (
        "SyncedElement represents another LogicalElement that is "
        "synchronized with the entity referenced as SystemElement.") ]
    CIM_LogicalElement REF SyncedElement;
    
    [Description (
        "The point in time that the Elements were synchronized.") ]
    datetime WhenSynced;
    
    [Description (
        "Boolean indicating whether synchronization is "
        "maintained.") ]
    boolean SyncMaintained;
};


// ==================================================================
// System
// ==================================================================
[Abstract, Version ("2.7.0"), Description (
    "CIM_System represents an entity made up of component "
    "parts (defined by the SystemComponent relationship), that "
    "operates as a 'functional whole'. Systems are top level "
    "objects in the CIM hierarchy, requiring no scoping or weak "
    "relationships in order to exist and have context. It should "
    "be reasonable to uniquely name and manage a System at an "
    "enterprise level. For example, a ComputerSystem is a kind of "
    "System that can be uniquely named and independently managed "
    "in an enterprise. However, this is not true for the power "
    "supply (or the power supply sub-'system') within "
    "the computer. \n"
    "\n"
    "Although a System may be viewed as a Collection, this is "
    "not the correct model. A Collection is simply a 'bag' "
    "that 'holds' its members. A System is a higher level "
    "abstraction, built out of its individual components. It "
    "is more than a sum of its parts. Note that System is a "
    "subclass of EnabledLogicalElement which allows the entire "
    "abstraction to be functionally enabled/disabled - at a higher "
    "level than enabling/disabling its component parts.") ]
class CIM_System : CIM_EnabledLogicalElement {
    
    [Key, MaxLen (256), Description (
        "CreationClassName indicates the name of the class or the "
        "subclass used in the creation of an instance. When used "
        "with the other key properties of this class, this property "
        "allows all instances of this class and its subclasses to "
        "be uniquely identified.") ]
    string CreationClassName;
    
    [Key, MaxLen (256), Override ("Name"), Description (
        "The inherited Name serves as key of a System instance in " 
        "an enterprise environment.") ] 
    string Name;
    
    [MaxLen (64), Description (
        "The System object and its derivatives are Top Level Objects "
        "of CIM. They provide the scope for numerous components. " 
        "Having unique System keys is required. A heuristic can be "
        "defined in individual System subclasses to attempt to always "
        "generate the same System Name Key. The NameFormat property "
        "identifies how the System name was generated, using "
        "the subclass' heuristic.") ] 
    string NameFormat;
    
    [MaxLen (64), Write, Description (
        "The name of the primary system owner. The system owner "
        "is the primary user of the system."),
        MappingStrings {
            "MIF.DMTF|General Information|001.3"} ]  
    string PrimaryOwnerName;
    
    [MaxLen (256), Write, Description (
        "A string that provides information on how the primary system "
        "owner can be reached (e.g. phone number, email address, "
        "...)."),
        MappingStrings {
            "MIF.DMTF|General Information|001.4"} ] 
    string PrimaryOwnerContact;
    
    [Write, Description (
        "  An array (bag) of strings that specify the administrator"
        "-defined roles this System plays in the managed environment. "
        "Examples might be 'Building 8 print server' or 'Boise user "
        "directories'. A single system may perform multiple roles. \n"
        "  Note that instrumentation's view of a System's 'roles' is "
        "defined by instantiating a specific subclass of System and/"
        "or by properties in a subclass.  For example, a "
        "ComputerSystem's purpose is defined using the Dedicated and "
        "OtherDedicatedDescription properties.") ]
    string Roles[];
};


// ==================================================================
// SystemComponent
// ==================================================================
[Association, Aggregation, Version ("2.7.0"), Description (
    "CIM_SystemComponent is a specialization of the CIM_Component "
    "association that establishes 'part of' relationships between "
    "a System and any ManagedSystemElements of which it is "
    "composed. \n" 
    "The use of this association is cautioned - versus the use "
    "of a subclass such as SystemDevice, or a peer association such "
    "as HostedService.  This class is very broadly defined which can "
    "lead to erroneous use.  For example, Access Points that are "
    "dependent on (and hosted on) a System are NOT Components of the "
    "System. The System is not made up of any AccessPoint 'parts', "
    "which is why a Dependency association, HostedAccessPoint, was "
    "defined.  Similarly, a PhysicalPackage is not a 'part' of a "
    "System, since the physical element exists independently of any "
    "internal components, software, etc. In fact, again, a Dependency "
    "relationship is true - where a ComputerSystem is Dependent on its "
    "packaging, as described by the ComputerSystemPackage "
    "association.") ] 
class CIM_SystemComponent : CIM_Component {
      
    [Override ("GroupComponent"), Aggregate, 
        Description ("The parent System in the Association.") ] 
    CIM_System REF GroupComponent;
      
    [Override ("PartComponent"), Description (
        "The child element that is a component of a System.") ] 
    CIM_ManagedSystemElement REF PartComponent;
}; 
     

// ==================================================================
// AdminDomain
// ==================================================================
[Version ("2.6.0"), Description (
    "  This is a special grouping of ManagedSystemElements. The "
    "grouping is viewed as a single entity, reflecting that all "
    "of its components are administered similarly - either by "
    "the same user, group of users or policy. It serves as "
    "an aggregation point to associate one or more of the "
    "following elements: network devices, such as routers and "
    "switches, servers, and other resources that can be "
    "accessed by end systems. This grouping of devices "
    "plays an essential role in ensuring that the same "
    "administrative policy and actions are applied to all "
    "of the devices in the grouping. The specific behavior "
    "and/or semantics of the AdminDomain can be identified "
    "through its aggregated and associated entities. \n") ]
class CIM_AdminDomain : CIM_System {
    
    [Override ("NameFormat"), Description (
        "The NameFormat property identifies how the Name of the "
        "AdminDomain is generated, using the heuristic specified "
        "in the CIM V2 System Model spec. It assumes that the "
        "documented rules are traversed in order, to determine and "
        "assign a Name. The NameFormat Values list defines the "
        "precedence order for assigning the Name of the "
        "AdminDomain."), 
        ValueMap {"Other", "AS", "NAP", "NOC", "POP", "RNP", "IP",
            "IPX", "SNA", "Dial", "WAN", "LAN", "ISDN", "Frame Relay",
            "ATM", "E.164", "IB", "FC", "Policy Repository"},
        Values {"Other", "Autonomous System",
            "Network Access Provider", "Network Operations Center",
            "Point of Presence", "Regional Network Provider",
            "IP", "IPX", "SNA", "Dial", "WAN", "LAN", "ISDN",
            "Frame Relay", "ATM", "E.164", "Infiniband", 
            "Fibre Channel", "Policy Repository"} ]
    string NameFormat;
};


// ==================================================================
// ContainedDomain
// ==================================================================
[Association, Aggregation, Version ("2.6.0"), Description (
    "A relationship that aggregates one or more lower-level "
    "AdminDomain instances into a higher-level AdminDomain.") ]
class CIM_ContainedDomain: CIM_SystemComponent {
    
    [Override ("GroupComponent"), Aggregate, Description (
        "An AdminDomain that aggregates other AdminDomains.") ]
    CIM_AdminDomain REF GroupComponent;
    
    [Override ("PartComponent"), Description (
        "An AdminDomain aggregated by another AdminDomain.") ]
    CIM_AdminDomain REF PartComponent;
};


// ==================================================================
// Service
// ==================================================================  
[Abstract, Version ("2.7.0"), Description (
    "A CIM_Service is a Logical Element that contains the "
    "information necessary to represent and manage the "
    "functionality provided by a Device and/or SoftwareFeature. "
    "A Service is a general-purpose object to configure and "
    "manage the implementation of functionality.  It is not the "
    "functionality itself.") ] 
class CIM_Service : CIM_EnabledLogicalElement {
    
    [Propagated ("CIM_System.CreationClassName"), Key, MaxLen (256), 
        Description (
            "The scoping System's CreationClassName.") ] 
    string SystemCreationClassName;
      
    [Propagated ("CIM_System.Name"), Key, MaxLen (256),
        Description (
            "The scoping System's Name.") ] 
    string SystemName;
    
    [Key, MaxLen (256), Description (
        "CreationClassName indicates the name of the class or the "
        "subclass used in the creation of an instance. When used "
        "with the other key properties of this class, this property "
        "allows all instances of this class and its subclasses to "
        "be uniquely identified.") ]
    string CreationClassName;
      
    [Override ("Name"), Key, MaxLen (256), Description (
        "The Name property uniquely identifies the Service and "
        "provides an indication of the functionality that is "
        "managed. This functionality is described in more detail in "
        "the object's Description property.") ] 
    string Name;
       
    [MaxLen (64), Write, Description (
        "The name of the primary owner for the service, if "
        "one is defined. The primary owner is the initial "
        "support contact for the Service."),
        MappingStrings {"MIF.DMTF|General Information|001.3"} ]  
    string PrimaryOwnerName;

    [MaxLen (256), Write, Description (
        "A string that provides information on how the primary "
        "owner of the Service can be reached (e.g. phone "
        "number, email address, ...)."),
        MappingStrings {"MIF.DMTF|General Information|001.4"} ] 
    string PrimaryOwnerContact;
    
    [MaxLen (10), 
        Deprecated {"CIM_Service.EnabledDefault"}, 
        Description (
            "StartMode is a string value indicating whether the "
            "Service is automatically started by a System, Operating "
            "System, etc. or only started upon request. This property "
            "is deprecated in lieu of the EnabledDefault property "
            "inherited from EnabledLogicalElement, which addresses "
            "the same semantics. The change to a uint16 data "
            "type was discussed when CIM V2.0 was defined. However, "
            "existing V1.0 implementations used the string "
            "property and did not want to modify their code. "
            "Therefore, StartMode was grandfathered into the Schema. "
            "Use of the Deprecated qualifier allows the maintenance "
            "of the existing property, but also permits an improved, "
            "clarified definition using EnabledDefault."),  
        ValueMap {"Automatic", "Manual"} ] 
    string StartMode;
   
    [Description (
        "Started is a boolean indicating whether the Service "
        "has been started (TRUE), or stopped (FALSE).") ] 
    boolean Started;
    
    [Description (
        "The StartService method places the Service in the started "
        "state. Note that this method's function overlaps with the "
        "RequestedState property. RequestedState was added to "
        "the model to maintain a record (i.e., a persisted value) "
        "of the last state request. Invoking the StartService "
        "method should set the RequestedState property appropriately."
        " The method returns an integer value of 0 if the Service was "
        "successfully started, 1 if the request is not supported and "
        "any other number to indicate an error. In a subclass, the "
        "set of possible return codes could be specified, using a "
        "ValueMap qualifier on the method. The strings to which the "
        "ValueMap contents are 'translated' may also be specified in "
        "the subclass as a Values array qualifier.") ] 
    uint32 StartService();
    
    [Description (
        "The StopService method places the Service in the stopped "
        "state. Note that this method's function overlaps with the "
        "RequestedState property. RequestedState was added to "
        "the model to maintain a record (i.e., a persisted value) "
        "of the last state request. Invoking the StopService "
        "method should set the RequestedState property appropriately."
        " The method returns an integer value of 0 if the Service was "
        "successfully stopped, 1 if the request is not supported and "
        "any other number to indicate an error. In a subclass, the "
        "set of possible return codes could be specified, using a "
        "ValueMap qualifier on the method. The strings to which the "
        "ValueMap contents are 'translated' may also be specified in "
        "the subclass as a Values array qualifier.") ] 
    uint32 StopService();
};

     
// ==================================================================
// HostedService
// ==================================================================
[Association, Version ("2.6.0"), Description (
    "CIM_HostedService is an association between a Service and "
    "the System on which the functionality resides.  The "
    "cardinality of this association is 1-to-many.  A System may "
    "host many Services. Services are weak with respect to their "
    "hosting System. Heuristic:  A Service is hosted on the "
    "System where the LogicalDevices or SoftwareFeatures that "
    "implement the Service are located.  The model does not "
    "represent Services hosted across multiple systems. This is "
    "modeled as an ApplicationSystem that acts as an aggregation "
    "point for Services, that are each located on a single "
    "host.") ] 
class CIM_HostedService : CIM_Dependency {
    
    [Override ("Antecedent"), Max (1), Min (1),
        Description ("The hosting System.") ] 
    CIM_System REF Antecedent;
    
    [Override ("Dependent"), Weak,
        Description ("The Service hosted on the System.") ] 
    CIM_Service REF Dependent;
};

     
// ==================================================================
// ProvidesServiceToElement
// ==================================================================
[Association, Deprecated {"CIM_ServiceAvailableToElement"}, 
    Version ("2.7.0"), Description (
    "The use of the CIM_ProvidesServiceToElement class has been "
    "deprecated.  Instead, ServiceAvailableToElement conveys the "
    "semantics of 'use', while the subclasses of ProvidesService"
    "ToElement (or the ConcreteDependency  association) describe "
    "dependency relationships. CIM_ProvidesServiceToElement was "
    "meant to generalize the ServiceServiceDependency association. "
    "It tried to indicate that ManagedElements may use the "
    "functionality provided by one or more Services. An example is "
    "that a Processor and an enclosure (a PhysicalElement) may use "
    "AlertOnLAN Services to signal an incomplete or erroneous boot. "
    "In reality, AlertOnLAN is simply a HostedService on a computer "
    "system that is generally 'available for 'use' and not a "
    "dependency of the processor or enclosure. To describe that use "
    "of the service may be restricted or have limited availability/"
    "applicability, then the CIM_ServiceAvailableToElement "
    "association would be instantiated.") ]
class CIM_ProvidesServiceToElement : CIM_Dependency {
 
    [Override ("Antecedent"), 
        Deprecated {"CIM_ServiceAvailableToElement.ServiceProvided"}, 
        Description ("The Service provided.") ]
    CIM_Service REF Antecedent;
 
    [Override ("Dependent"), 
        Deprecated {"CIM_ServiceAvailableToElement.UserOfService"},
        Description ("The ManagedElement dependent on the Service.") ]
    CIM_ManagedElement REF Dependent;
};

 
// ==================================================================
// ServiceAvailableToElement
// ==================================================================
[Association, Version ("2.7.0"), Description (
    "CIM_ServiceAvailableToElement conveys the semantics "
    "of a Service being available for the 'use' of a ManagedElement. "
    "An example is that a Processor and an enclosure "
    "(a PhysicalElement) may use AlertOnLAN Services to signal an "
    "incomplete or erroneous boot.  In reality, AlertOnLAN is simply a "
    "HostedService on a computer system that is generally 'available for "
    "use', and not a dependency of the processor or enclosure. To "
    "describe that use of this service is restricted or has limited "
    "availability/applicability, then the CIM_ServiceAvailableToElement "
    "association would be instantiated between the Service and specific "
    "CIM_Processors and CIM_Chassis .") ]
class CIM_ServiceAvailableToElement {
 
    [Key, Description (
        "The Service that is available.") ]
    CIM_Service REF ServiceProvided;
 
    [Key, Description (
        "The ManagedElement that may use the Service.") ]
    CIM_ManagedElement REF UserOfService;
};

 
// ===================================================================
// ServiceAffectsElement
// ===================================================================
[Association, Version ("2.7.0"), Description (
    "ServiceAffectsElement represents an association between a "
    "Service and the ManagedElement(s) that may be affected by its "
    "execution. Instantiating this association indicates that running "
    "the service will pose some burden on the ManagedElement "
    "that may affect performance, throughput, availability, "
    "etc.") ]
class CIM_ServiceAffectsElement {  
 
    [Key, Description (
        "The Managed Element affected by the Service.")]
    CIM_ManagedElement REF AffectedElement;
 
    [Key, Description (
        "The Service that is affecting the ManagedElement.")]
    CIM_Service REF AffectingElement; 
 
    [Description (
        "An enumeration describing the 'effect' on the "
        "ManagedElement. This array corresponds to the "
        "OtherElementEffectsDescriptions array, where the "
        "latter provides details related to the high-level "
        "'effects' enumerated by this property. Additional "
        "detail is required if the ElementEffects array contains "
        "the value 1, \"Other\"."),
        ArrayType ("Indexed"),
        ValueMap {"0", "1", "2", "3", "4"},
        Values {"Unknown", "Other", "Exclusive Use", 
            "Performance Impact", "Element Integrity"},
        ModelCorrespondence {
        "CIM_ServiceAffectsElement.OtherElementEffectsDescriptions"} ]
    uint16 ElementEffects[];

    [Description (
        "Provides details for the 'effect' at the corresponding array "
        "position in ElementEffects. This information is required "
        "ElementEffects contains the value 1 (\"Other\")."),
        ArrayType ("Indexed"),
        ModelCorrespondence {
            "CIM_ServiceAffectsElement.ElementEffects"} ]
    string OtherElementEffectsDescriptions[];
};


// ==================================================================
// ServiceServiceDependency
// ==================================================================
[Association, Version ("2.7.0"), Description (
    "   CIM_ServiceServiceDependency is an association between a " 
    "Service and another Service, indicating that the latter is "
    "required to be present, required to have completed, or must " 
    "be absent for the former Service to provide its "
    "functionality. For example, Boot Services may be dependent "
    "upon underlying system initialization Services. "
    "In the case of the initialization Services, the Boot Service "
    "may be dependent on the init Services completing. \n"
    "   Examining the ServiceServiceDependency class definition, "
    "note that its superclass ProvidesServiceToElement is deprecated. "
    "Unfortunately, ProvidesServiceToElement cannot be removed from "
    "the object hierarchy without a major Schema release. "
    "When/if this occurs, the ProvidesServiceToElement superclass "
    "will be removed, and ServiceServiceDependency will subclass "
    "from CIM_Dependency directly. " ) ] 
class CIM_ServiceServiceDependency : CIM_ProvidesServiceToElement {
 
    [Override ("Antecedent"), 
        Description ("The required Service.") ] 
    CIM_Service REF Antecedent;
 
    [Override ("Dependent"), Description (
        "The Service that is dependent on an underlying Service.") ] 
    CIM_Service REF Dependent;
 
    [Description (
        "The nature of the Service to Service dependency. This "
        "property describes that the associated Service must have "
        "completed (value=2), must be started (3) or must not be "
        "started (4) in order for the Service to function."),  
        ValueMap {"0", "1", "2", "3", "4"},
        Values {"Unknown", "Other", "Service Must Have Completed",
            "Service Must Be Started", 
            "Service Must Not Be Started"} ]
    uint16 TypeOfDependency;
 
    [Description (
        "This property describes that the Antecedent Service must "
        "be restarted after the Dependent operation is complete.") ]
    boolean RestartService;
};


// ==================================================================
// ServiceComponent
// ==================================================================
[Association, Aggregation, Version ("2.6.0"), Description (
    "The ServiceComponent aggregation models a set of "
    "subordinate Services that are aggregated together to form "
    "a higher-level service.") ]
class CIM_ServiceComponent : CIM_Component {
    [Override ("GroupComponent"), Aggregate, Description (
        "The parent Service.") ]
    CIM_Service REF GroupComponent;
    
    [Override ("PartComponent"), Description (
        "The component Service.") ]
   CIM_Service REF PartComponent;
};

     
// ==================================================================
// ServiceAccessPoint
// ==================================================================
[Abstract, Version ("2.6.0"), Description (
    "CIM_ServiceAccessPoint represents the ability to utilize or "
    "invoke a Service.  Access points represent that a Service is "
    "made available to other entities for use.") ] 
class CIM_ServiceAccessPoint : CIM_EnabledLogicalElement {
      
    [Propagated ("CIM_System.CreationClassName"), Key, MaxLen (256), 
        Description (
            "The scoping System's CreationClassName.") ] 
    string SystemCreationClassName;
    
    [Propagated ("CIM_System.Name"), Key, MaxLen (256), Description (
        "The scoping System's Name.") ] 
    string SystemName;
    
    [Key, MaxLen (256), Description (
        "CreationClassName indicates the name of the class or the "
        "subclass used in the creation of an instance. When used "
        "with the other key properties of this class, this property "
        "allows all instances of this class and its subclasses to "
        "be uniquely identified.") ]
    string CreationClassName;
    
    [Override ("Name"), Key, MaxLen (256), Description (
        "The Name property uniquely identifies the ServiceAccessPoint "
        "and provides an indication of the functionality that is "
        "managed.  This functionality is described in more detail in "
        "the object's Description property.") ] 
   string Name;
};

     
// ==================================================================
// HostedAccessPoint
// ==================================================================
[Association, Version ("2.6.0"), Description (
    "CIM_HostedAccessPoint is an association between a Service"
    "AccessPoint and the System on which it is provided. The "
    "cardinality of this association is 1-to-many and is weak "
    "with respect to the System. Each System may host many "
    "ServiceAccessPoints.  Heuristic:  If the implementation of "
    "the ServiceAccessPoint is modeled, it must be "
    "implemented by a Device or SoftwareFeature that is part of "
    "the System hosting the ServiceAccessPoint.") ] 
class CIM_HostedAccessPoint:CIM_Dependency {
   
    [Override ("Antecedent"), Max (1), Min (1), 
        Description ("The hosting System.") ] 
    CIM_System REF Antecedent;
    
    [Override ("Dependent"), Weak,
        Description ("The SAP(s) that are hosted on this System.") ] 
    CIM_ServiceAccessPoint REF Dependent;
};
   

// ==================================================================
// ServiceSAPDependency
// ==================================================================
[Association, Version ("2.6.0"), Description (
    "CIM_ServiceSAPDependency is an association between a Service "
    "and a ServiceAccessPoint indicating that the referenced SAP "
    "is utilized by the Service to provide its functionality. For "
    "example, Boot Services may invoke BIOS' Disk Services "
    "(interrupts) in order to function.") ] 
class CIM_ServiceSAPDependency : CIM_Dependency {
    
    [Override ("Antecedent"), Description (
        "The required ServiceAccessPoint.") ] 
    CIM_ServiceAccessPoint REF Antecedent;
    
    [Override ("Dependent"), Description (
        "The Service that is dependent on an underlying SAP.") ] 
    CIM_Service REF Dependent;
};

     
// ==================================================================
// ServiceAccessBySAP
// ==================================================================
[Association, Version ("2.6.0"), Description (
    "CIM_ServiceAccessBySAP is an association that identifies the "
    "access points for a Service. For example, a printer may be "
    "accessed by Netware, MacIntosh or Windows ServiceAccess"
    "Points, potentially hosted on different Systems.") ] 
class CIM_ServiceAccessBySAP : CIM_Dependency {

    [Override ("Antecedent"),
        Description ("The Service.") ] 
    CIM_Service REF Antecedent;
      
    [Override ("Dependent"), Description (
        "An Access Point for a Service. Access points are dependent " 
        "in this relationship since they have no function without a "
        "corresponding Service.") ] 
    CIM_ServiceAccessPoint REF Dependent;
};

     
// ==================================================================
// SAPSAPDependency
// ==================================================================
[Association, Version ("2.6.0"), Description (
    "CIM_SAPSAPDependency is an association between a Service"
    "AccessPoint and another ServiceAccessPoint indicating that "
    "the latter is required in order for the former ServiceAccess"
    "Point to utilize or connect with its Service. For example, "
    "to print at a network printer, local Print Access Points "
    "must utilize underlying network-related SAPs, or "
    "ProtocolEndpoints, in order to send the print request.") ] 
class CIM_SAPSAPDependency : CIM_Dependency {

    [Override ("Antecedent"), Description (
        "The required ServiceAccessPoint.") ] 
    CIM_ServiceAccessPoint REF Antecedent;
      
    [Override ("Dependent"), Description (
        "The ServiceAccessPoint that is dependent on an underlying "
        "SAP.") ] 
    CIM_ServiceAccessPoint REF Dependent;
};


// ==================================================================
// ActiveConnection
// ==================================================================
[Association, Version ("2.7.0"), Description (
    "This association defines a connection that is currently "
    "communicating, or is configured to communicate, "
    "between two ServiceAccessPoints. It is used when the "
    "connection is not treated as a ManagedElement itself "
    "(i.e., with Status, statistics, etc.), but its "
    "existence is known. The SAPs that are connected are "
    "typically at the same networking or application layer.") ]
class CIM_ActiveConnection : CIM_SAPSAPDependency {
        
    [Override ("Antecedent"), Description (
        "A ServiceAccessPoint that is configured to communicate "
        "and/or is actively communicating with the Dependent "
        "SAP. In a unidirectional connection, this is the "
        "SAP which is transmitting.") ]
    CIM_ServiceAccessPoint REF Antecedent;
        
    [Override ("Dependent"), Description (
        "A second SeriveAccessPoint that is/can communicate "
        "with the Antecedent SAP. In a unidirectional "
        "connection, this is the SAP that is receiving the "
        "communication.") ] 
    CIM_ServiceAccessPoint REF Dependent;
        
    [Deprecated {"No value"}, Description (
        "The type of traffic that is carried over this "
        "connection. This property is deprecated since it is "
        "incorrectly placed on the association. Unicast, "
        "broadcast or other traffic types are not a function "
        "of the connection between the referenced endpoints, "
        "but on the addressing, protocol, and basic functionality "
        "of the endpoints."),
        ValueMap {"0", "1", "2", "3", "4", "5" },
        Values {"Unknown", "Other", "Unicast", "Broadcast",
            "Multicast", "Anycast"},
        ModelCorrespondence {
            "CIM_ActiveConnection.OtherTrafficDescription" } ]
    uint16 TrafficType;
        
    [Deprecated {"No value"}, MaxLen(64), Description (
        "A string describing the type of traffic that is being "
        "carried over this instance when its Type property is set "
        "to 1 (e.g., 'Other'). This property is deprecated since it is "
        "incorrectly placed on the association. Unicast, "
        "broadcast or other traffic types are not a function "
        "of the connection between the referenced endpoints, "
        "but on the addressing, protocol, and basic functionality "
        "of the endpoints."),
        ModelCorrespondence {
            "CIM_ActiveConnection.TrafficType" } ]
    string OtherTrafficDescription;
       
    [Description (
        "TRUE means that this connection is uni-directional; FALSE "
        "means that this connection is bi-directional. When the "
        "connection is unidirectional, the 'speaker' should be "
        "defined as the Antecedent reference. In a bidirectional "
        "connection, the selection of which AccessPoint is the "
        "Antecedent or Dependent is immaterial.") ]
    boolean IsUnidirectional;
};


// ==================================================================
// RemoteServiceAccessPoint
// ==================================================================
[Version ("2.7.0"), Description (
    "   RemoteServiceAccessPoint describes access and/or "
    "addressing information for a remote connection, that is "
    "known to a 'local' network element. This information is "
    "scoped/contained by the 'local' network element, since "
    "this is the context in which it is 'remote'. \n\n"
    "   Why the remote access point is relevant and information "
    "on its use are described by subclassing RemoteService"
    "AccessPoint, or by associating to it.") ]
class CIM_RemoteServiceAccessPoint : CIM_ServiceAccessPoint {
     
    [Description (
        "Access and/or addressing information for a remote "
        "connection. This can be a host name, network "
        "address or similar information."),
        ModelCorrespondence {
            "CIM_RemoteServiceAccessPoint.InfoFormat"} ]
    string AccessInfo;
     
    [Description (
        "An enumerated integer describing the format and "
        "interpretation of the AccessInfo property."),
        ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", 
            "9", "10..99", "100", "101", "102", "103", "104", 
            "105..199", "200", "32768..65535"},
        Values {"Other", "Host Name", "Ipv4 Address",
            "Ipv6 Address", "IPX Address", "DECnet Address", 
            "SNA Address", "Autonomous System Number", 
            "MPLS Label", "DMTF Reserved", "Dial String", 
            "Ethernet Address", "Token Ring Address", 
            "ATM Address", "Frame Relay Address", 
            "DMTF Reserved", "URL", "Vendor Specific"},
        ModelCorrespondence {
            "CIM_RemoteServiceAccessPoint.OtherInfoFormatDescription"} ]
    uint16 InfoFormat;
     
    [Description (
        "Describes the format when the property InfoFormat "
        "is set to 1 (\"Other\")."),
        ModelCorrespondence {
            "CIM_RemoteServiceAccessPoint.InfoFormat"} ]
    string OtherInfoFormatDescription;
};


// ==================================================================
// RemotePort
// ==================================================================
[Version ("2.7.0"), Description (
    "RemotePort adds port information to the access data "
    "(such as IP Address), specified in and inherited from "
    "RemoteServiceAccessPoint. For example, using the "
    "additional properties in this class, one could indicate that "
    "UDP Port 123 is accessed at IP Address xyz. The IP Address "
    "would be specified in the inherited AccessInfo property, "
    "while the UDP Port number would be specified in this "
    "class' property, PortInfo.") ]
class CIM_RemotePort : CIM_RemoteServiceAccessPoint {
      
    [Description (
        "Port information that may further specify the "
        "remote access information."), 
        ModelCorrespondence {
            "CIM_RemotePort.PortProtocol"} ]
    string PortInfo;
      
    [Description (
        "An enumerated integer describing the protocol "
        "of the port addressed by PortInformation."),
        ValueMap {"1", "2", "3", "32768..65535"}, 
        Values {"Other", "TCP", "UDP", "Vendor Specific"},
        ModelCorrespondence {
            "CIM_RemotePort.OtherProtocolDescription"} ]
    uint16 PortProtocol;
      
    [Description (
        "Describes the protocol when the property PortProtocol "
        "is set to 1 (\"Other\")."),
        ModelCorrespondence {
            "CIM_RemotePort.PortProtocol"} ]
    string OtherProtocolDescription;
};


// ==================================================================
// ServiceAccessURI
// ==================================================================
[Version ("2.7.0"), Description (
    "CIM_ServiceAccessURI represents the ability to utilize or "
    "invoke a Service via a uniform resource identifier. "
    "RFC 1738 describes the Uniform Resource Locator which is a "
    "more specific form of a URI, and RFC 2396 describes the broader, "
    "inclusive URI. Quoting from the RFC, 'A Uniform Resource "
    "Identifier (URI) is a compact string of characters for identifying "
    "an abstract or physical resource.' In the context of a "
    "ServiceAccessPoint, a URI contains the information necessary "
    "to access an associated service (associated via "
    "ServiceAccessBySAP), using a syntax specific to that service.") ]
class CIM_ServiceAccessURI : CIM_ServiceAccessPoint {

    [Required, MaxLen (256), Description (
        "The LabeledURI property is based on RFC 2079 and its value "
        "and syntax is service specific.") ]
    string LabeledURI;
};


// ==================================================================
// ProtocolEndpoint
// ==================================================================
[Version ("2.7.0"), Description (
    "A communication point from which data may be sent or "
    "received. ProtocolEndpoints link system/computer interfaces "
    "to LogicalNetworks.") ]
class CIM_ProtocolEndpoint : CIM_ServiceAccessPoint {

    [Override ("Name"), MaxLen(256), Description (
        "A string which identifies this ProtocolEndpoint with either "
        "a port or an interface on a device. To ensure uniqueness, "
        "the Name property should be prepended or appended with "
        "information from the Type or OtherTypeDescription "
        "properties. The method chosen is described in the "
        "NameFormat property of this class.") ]
    string Name;

    [MaxLen (256), Description (
        "NameFormat contains the naming heuristic that is chosen to "
        "ensure that the value of the Name property is unique. For "
        "example, one might choose to prepend the name of the port "
        "or interface with the Type of ProtocolEndpoint that this "
        "instance is (e.g., IPv4) followed by an underscore.") ]
    string NameFormat;

    [Description (
        "ProtocolType is an enumeration providing information to "
        "categorize and classify different instances of this class. "
        "For most instances, information in this enumeration and the "
        "subclass' definition overlap. However, there are several cases "
        "where a specific subclass of ProtocolEndpoint is not required "
        "(for example, there is no Fibre Channel Endpoint). Hence, this "
        "property is needed to define the type of Endpoint. Note that "
        "in a future major release of the CIM Schema, it is likely "
        "that ProtocolEndpoint will be ABSTRACT, forcing "
        "subclassing and removing the need for this property."), 
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 
            "10", "11", "12", "13", "14", "15", "16", "17", "18", 
            "19", "20", "21", "22", "23", "24", "25", "26", "27"},
        Values {"Unknown", "Other", "IPv4", "IPv6", "IPX", 
            "AppleTalk", "DECnet", "SNA", "CONP", "CLNP",
            "VINES", "XNS", "ATM", "Frame Relay",
            "Ethernet", "TokenRing", "FDDI", "Infiniband", 
            "Fibre Channel", "ISDN BRI Endpoint", 
            "ISDN B Channel Endpoint", "ISDN D Channel Endpoint", 
            // 22
            "IPv4/v6", "BGP", "OSPF", "MPLS", "UDP", "TCP"},
        ModelCorrespondence {
            "CIM_ProtocolEndpoint.OtherTypeDescription"} ] 
    uint16 ProtocolType;

    [MaxLen(64), Description (
        "A string describing the type of ProtocolEndpoint when "
        "the Type property of this class (or any of its "
        "subclasses) is set to 1 (i.e., \"Other\"). This "
        "property should be set to NULL when the Type property "
        "is any value other than 1."),
        ModelCorrespondence {"CIM_ProtocolEndpoint.ProtocolType"} ]
    string OtherTypeDescription;
};


// ==================================================================
// BindsTo
// ==================================================================
[Association, Version ("2.6.0"), Description (
    "This association establishes a ServiceAccessPoint "
    "as a requestor of protocol services from a "
    "ProtocolEndpoint. Typically, this association runs "
    "between SAPs and endpoints on a single system. Since a "
    "ProtocolEndpoint is a kind of ServiceAccessPoint, this "
    "binding can be used to establish a layering of two "
    "protocols, the upper layer represented by the Dependent "
    "and the lower layer represented by the Antecedent.") ]
class CIM_BindsTo : CIM_SAPSAPDependency {

    [Override ("Antecedent"), Description (
        "The lower-level endpoint which is accessed by the SAP.") ]
    CIM_ProtocolEndpoint REF Antecedent;

    [Override ("Dependent"), Description (
        "The AccessPoint or ProtocolEndpoint dependent on the "
        "lower level endpoint.") ]
    CIM_ServiceAccessPoint REF Dependent;
};


// ==================================================================
// ProvidesEndpoint
// ==================================================================
[Association, Version ("2.7.0"), Description (
    "This association represents a ProtocolEndpoint provided "
    "by a Service, to allow access to the Service.") ]
class CIM_ProvidesEndpoint : CIM_ServiceAccessBySAP {

    [Override ("Antecedent"), Description (
        "The Service that is accessed by the ProtocolEndpoint.") ]
    CIM_Service REF Antecedent;

    [Override ("Dependent"), Description (
        "The ProtocolEndpoint that provides access to the "
        "Service.") ] 
    CIM_ProtocolEndpoint REF Dependent;
};


// ===================================================================
// end of file
// ===================================================================
