// ===================================================================
// Title: 	  System MOF specification 2.3
// Filename:  CIM_System23.mof
// Author:    DMTF System and Devices Working Group
// Description: The object classes below are listed in an order that
//              avoids forward references. Required objects, defined 
//		    by other working groups, are omitted. 
// Date:  04/14/1998 - Version 2.0
//        06/16/1998 - V2.0 Errata
//		- CR233, Format for specifying Propagated keys uses
//                period, not colon and CIM_ missing from class name
//			(CIM_OperatingSystemSoftwareFeature)
//	    09/29/1998 - Version 2.1
//		- CR251, Remove DMI mapping reference from OperatingSystem.
//			NumberOfUsers and move to LocalDateTime
//		- CR268, Change cardinality of the Antecedent reference
//			of the ParticipatingCS association (to Min(1))
//		- CR273, Remove repetition of the Values array from the
//			descriptions of several properties
//		- CR276b, Add to the enumeration for UnitaryComputerSystem.
//			PowerState
//		- CR290, Add ModelCorrespondence to "linked" properties
//		- CR293, Correct xxxMemory properties of OperatingSystem
//			and add MaxProcessMemorySize property
//	    06/08/1999 - Version 2.2
//		- CR354, Update the Values array for "power save" for
//			UnitaryComputerSystem (both the property and method)
//		- CR355a, Update the method descriptions for SetPowerState,
//                 AddNode, EvictNode, Reboot and Shutdown indicating 
//                 that Values-ValueMap qualifiers can be defined for 
//                 return codes
//          - CR356a, Put keys on the references of Export
//		- CR358a, Add ClusterSize property to FileSystem
//		- CR363, Update OperatingSystem.OSType enumeration and the
//			 description for OperatingSystem.OtherTypeDescription
//		- CR364, Create TotalVisibleMemorySize property on 
//			 OperatingSystem
//		- CR368, Update ComponentCS' Description and add new 
//			 associations, SystemPartition and SystemBIOS
//		- CR369, Update FileSystem - CodeSet's Description and 
//			 enum, and create a new property, FileSystemType
//		- CR370a, Update BIOSFeature.Characteristics enumeration and
//			 add ListOfLanguages and CurrentLanguage properties
//			 to BIOSElement
//          - CR371, Add WakeUpType property to UnitaryComputerSystem
//		- CR374a, Update Process' Description
//		- CR383 and 409, Add OS/390, VSE and TPF to OS's OSType enum
//		- CR386, Add to the enums for Cluster.Types and 
//                 ParticipatingCS.RoleOfNode and update the latter's 
//			 Description
//		- CR388a, Create StorageLibrary object
//		- CR405, Add Counter and Gauge qualifiers
//		- CR407, Remove the word "automated" from StorageLibrary's
//			 Description / Update descriptions for AuditInProgress
//			 and MaxAuditTime
//		- CR408, Set ComputerSystem's cardinality in SystemPartition
//			 to Max(1)
//		- CR417a, Change cardinality of UnitaryComputerSystem in
//                 SystemBIOS (add Max(1)) and remove Min(1) from 
//			 ComputerSystem for RunningOS
//        07/06/1999 - Version 2.2.1
//		- CR423, Locale should be specified as en_US
//		- CR425, Update the DMI MappingStrings using the June
//			release of the master.mif
//	Date  02/18/2000 - Version 2.3
//		- CR433 Add new properties and enums from Master.MIF and new 
//			ModelCorrespondences 
//		- CR344 Update to CIM_FileSystem classes and associations
//		- CR437e, Diagnostic extensions, classes and associations.
//		- CR460a Add Gauge qualifier to properties
//		- CR473	Update to CIM_Mount association 
// ===================================================================



// ===================================================================
// Pragmas
// ===================================================================
#pragma locale ("en_US")


// ===================================================================
// ComponentCS
// ===================================================================
   [Association,
    Aggregation,
    Description (
       "A ComputerSystem can aggregate another ComputerSystem. "
       "This association can be used to model MPP Systems with "
       "workstation frontends, an I2O subsystem embedded in a Unitary"
       "ComputerSystem, or a System that splits functionality between "
       "two processors, potentially running different Operating"
       "Systems. For example, if a CISC Processor and its associated "
       "OperatingSystem, are used for user interface and file "
       "support, and a RISC Processor and its OS are used for complex "
       "mathematical operations, this could be modeled as two "
       "ComputerSystems where one aggregates the other. In some cases, "
       "this could be modeled as a Cluster. The difference is the "
       "focus of the relationship. ComponentCS represents that "
       "unique and distinct ComputerSystems are aggregated by a "
       "higher level CS object. However, each of the component CSs are "
       "still distinguishable entities and are only viewed as such. "
       "Alternately, with a Cluster, the ComputerSystems that "
       "participate in it are inconsequential, when viewed through the "
       "'Cluster System'.\n\n"
       "When instantiating or subclassing the ComponentCS "
       "relationship, care should be taken that the component "
       "ComputerSystem meets the definitional requirements of a "
       "ComputerSystem - ie, a functional whole that provides "
       "compute capabilities and aggregates System Devices, an "
       "OperatingSystem, etc.")
   ] 
class CIM_ComponentCS : CIM_SystemComponent
{
      [Override ("GroupComponent"),
       Aggregate,
       Description (
	  "The ComputerSystem that contains and/or aggregates other "
	  "Systems.")
      ]
   CIM_ComputerSystem REF GroupComponent;
      [Override ("PartComponent"), 
       Description ("The contained (Sub)ComputerSystem.")
      ]
   CIM_ComputerSystem REF PartComponent;
};

// ===================================================================
// UnitaryComputerSystem
// ===================================================================
   [Description (
       "A class derived from ComputerSystem that represents a Desktop, "
       "Mobile, NetPC, Server or other type of a single node Computer "
       "System.")
   ] 
class CIM_UnitaryComputerSystem : CIM_ComputerSystem
{
      [Description (
	  "This object contains the data needed to find either the "
	  "initial load device (its key) or the boot service to "
	  "request the operating system to start up. In addition, "
	  "the load parameters (ie, a pathname and parameters) "
	  "may also be specified.")
      ]
   string InitialLoadInfo[];
      [Description (
	  "This object contains the data identifying either the "
	  "initial load device (its key) or the boot service that "
	  "requested the last operating system load. In addition, "
	  "the load parameters (ie, a pathname and parameters) "
	  "may also be specified."),
	 MappingStrings {
	  "MIB.IETF|HOST-RESOURCES-MIB.hrSystemInitialLoadDevice",
	  "MIB.IETF|HOST-RESOURCES-MIB.hrSystemInitialLoadParameters", 
        "MIF.DMTF|Host System|001.3"}
      ]
   string LastLoadInfo;
      [Description (
	  "If enabled (value = 4), the UnitaryComputerSystem can be "
	  "reset via hardware (e.g. the power and reset buttons). If "
 	  "disabled (value = 3), hardware reset is not allowed. In "
	  "addition to Enabled and Disabled, other Values for the "
	  "property are also defined - \"Not Implemented\" (5), "
	  "\"Other\" (1) and \"Unknown\" (2)."),
       ValueMap {"1", "2", "3", "4", "5"},
	 Values {"Other", "Unknown", "Disabled",
	       "Enabled", "Not Implemented"},
       MappingStrings {"MIF.DMTF|System Hardware Security|001.4"}
      ]
   uint16 ResetCapability;
      [Description (
	  "Boolean indicating that the ComputerSystem, with its "
	  "running OperatingSystem, supports power management. This "
	  "boolean does not indicate that power management features are "
	  "currently enabled, or if enabled, what features are "
	  "supported. Refer to the PowerManagementCapabilities array "
	  "for this information. If this boolean is false, the integer "
	  "value 1 for the string, \"Not Supported\", should be the "
	  "only entry in the PowerManagementCapabilities array.")
      ]
   boolean PowerManagementSupported;	
      [Description(
	  "Indicates the specific power-related capabilities of a "
	  "ComputerSystem and its associated running OperatingSystem. "
	  "The values, 0=\"Unknown\", 1=\"Not Supported\", and "
	  "2=\"Disabled\" are self-explanatory. "
	  "The value, 3=\"Enabled\" indicates that the power management "
	  "features are currently enabled but the exact feature set "
	  "is unknown or the information is unavailable. "
	  "\"Power Saving Modes Entered Automatically\" (4) describes "
	  "that a system can change its power state based on usage or "
	  "other criteria. \"Power State Settable\" (5) indicates that "
	  "the SetPowerState method is supported. \"Power Cycling "
        "Supported\" (6) indicates that the SetPowerState method "
	  "can be invoked with the PowerState input variable set to 5 ("
	  "\"Power Cycle\"). \"Timed Power On Supported\" (7) indicates "
	  "that the SetPowerState method can be invoked with the Power"
	  "State input variable set to 5 (\"Power Cycle\") and the Time "
	  "parameter set to a specific date and time, or interval, "
	  "for power-on."),
       Values {"Unknown", "Not Supported", "Disabled", 
	       "Enabled", "Power Saving Modes Entered Automatically",
	       "Power State Settable", "Power Cycling Supported",
	       "Timed Power On Supported"},
       MappingStrings {"MIF.DMTF|System Power Controls|001.2"}
      ]
   uint16 PowerManagementCapabilities[];
      [Description(
        "Indicates the current power state of the ComputerSystem and "
        "its associated OperatingSystem. Regarding the Power Save "
        "states, these are defined as follows: Value 4 (\"Power Save "
        "- Unknown\") indicates that the System is known to be in a "
        "power save mode, but its exact status in this mode is "
        "unknown; 2 (\"Power Save - Low Power Mode\") indicates that "
        "the System is in a power save state but still functioning, "
        "and may exhibit degraded performance; 3 (\"Power Save - "
        "Standby\") describes that the System is not functioning but "
        "could be brought to full power 'quickly'; value 7 (\"Power Save "
        "- Warning\") indicates that the ComputerSystem is in a warning "
        "state, though also in a power save mode; and, values 8 and 9 "
        "describe the ACPI \"Hibernate\" and \"Soft Off\" states."),
       Values {"Unknown", "Full Power", "Power Save - Low Power Mode", 
             "Power Save - Standby", "Power Save - Unknown", 
             "Power Cycle", "Power Off", "Power Save - Warning", 
             "Power Save - Hibernate", "Power Save - Soft Off"}
      ]
   uint16 PowerState;
      [Description (
        "The event that caused the System to power up. This "
        "information is available in SMBIOS, in the Type 1 structure, "
        "the Wake Up Type attribute."),
       Values {"Reserved", "Other", "Unknown", "APM Timer", 
             "Modem Ring", "LAN Remote", "Power Switch", "PCI PME#", 
             "A/C Power Restored"}
      ]
   uint16 WakeUpType;
      [Description(
        "SetPowerState defines the desired power state of a "
        "ComputerSystem and its running OperatingSystem, and when "
        "the system should be put into that state. The PowerState "
        "parameter is specified as one of the following integer "
        "values: 1=\"Full Power\", 2=\"Power Save - Low Power Mode\", "
        "3=\"Power Save - Standby\", 4=\"Power Save - Other\", "
        "5=\"Power Cycle\", 6=\"Power Off\", 7=\"Hibernate\" and "
        "8=\"Soft Off\". The Time parameter (for all state changes "
        "but 5, \"Power Cycle\") indicates when the power state "
        "should be set, either as a regular date-time value or as "
        "an interval value (where the interval begins when the "
        "method invocation is received). When the PowerState "
        "parameter is equal to 5, \"Power Cycle\", the Time "
        "parameter indicates when the system should power on "
        "again. Power off is immediate. SetPowerState should "
        "return 0 if successful, 1 if the specified State and "
        "Time request is not supported, and some other value if "
        "any other error occurred. 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 SetPowerState(
    [IN, ValueMap {"1", "2", "3", "4", "5", "6", "7", "8"},
         Values {"Full Power", "Power Save - Low Power Mode", 
          "Power Save - Standby", "Power Save - Other", 
          "Power Cycle", "Power Off", "Hibernate", "Soft Off"}] 
         uint16 PowerState, 
    [IN] datetime Time);
};

// ===================================================================
// SystemPartition
// ===================================================================
   [Association, Aggregation, Description (
       "A Partition is an instance of a UnitaryComputerSystem (with "
       "its own OperatingSystem and Devices dedicated to the "
       "Partition) that is supported by underlying hardware and "
       "software. A Partition is not a virtualization of a Computer"
       "System, but the segmentation of the System's compute "
       "capabilities. Partitions can run independent copies of "
       "possibly different OperatingSystems and have dedicated "
       "Devices. The 'real', underlying System (perhaps a Cluster "
       "or another UnitaryComputerSystem) aggregates its "
       "Partitions. These semantics are described by the System"
       "Partition association.")
   ]
class CIM_SystemPartition : CIM_ComponentCS
{
      [Override ("GroupComponent"), Aggregate, Max (1),
       Description (
        "The 'underlying' ComputerSystem that hosts a Partition.")
      ]
   CIM_ComputerSystem REF GroupComponent;
      [Override ("PartComponent"), 
       Description ("The System Partition.")
      ]
   CIM_UnitaryComputerSystem REF PartComponent;
};

// ===================================================================
// VirtualComputerSystem
// ===================================================================
   [Description (
       "A class derived from ComputerSystem that represents the "
       "ability to virtualize or emulate another ComputerSystem.")
   ] 
class CIM_VirtualComputerSystem : CIM_ComputerSystem
{
      [Description (
        "A string describing the type of System or hardware platform "
	  "that is virtualized. OperatingSystem information is obtained "
	  "via the RunningOS inherited from ComputerSystem.")
      ]
   string VirtualSystem;
};

// ===================================================================
// HostingCS
// ===================================================================
   [Association,
    Description (
       "A VirtualComputerSystem is hosted on another ComputerSystem. "
       "This association makes that relationship explicit.")
   ] 
class CIM_HostingCS : CIM_Dependency
{
      [Override ("Antecedent"), 
       Description ("The hosting ComputerSystem."),
       Min (1)
      ]
   CIM_ComputerSystem REF Antecedent;
      [Override ("Dependent"), 
       Description ("The VirtualComputerSystem.")
      ]
   CIM_VirtualComputerSystem REF Dependent;
};

// ===================================================================
// Cluster
// ===================================================================
   [Description (
       "A class derived from ComputerSystem that 'is made up of' two "
       "or more ComputerSystems which operate together as an atomic, "
       "functional whole to increase the performance, resources and/or "
       "RAS (Reliability, Availability and Serviceability) of the "
       "component ComputerSystems, related to some aspects of these "
       "ComputerSystems.")
   ] 
class CIM_Cluster : CIM_ComputerSystem
{
      [Description (
	  "Interconnect is a free form string that describes the "
	  "interconnection mechanism for the Cluster.")
      ]
   string Interconnect;	
      [Description (
	  "InterconnectAddress indicates the address of the Cluster "
	  "System, which is dependent on the interconnection scheme. "
	  "If no address is available or applicable, a null string "
	  "should be used.")
      ]
   string InterconnectAddress;
      [Description (
	  "The cluster types. This specifies whether the cluster is for "
	  "failover (value=2), performance (3), etc. The values which "
	  "can be specified are not mutually exclusive. Thus, Types is "
	  "an array."),
       Values {"Unknown", "Other", "Failover", 
	       "Performance", "Distributed OS", "Node Grouping",
             "SysPlex"}
      ]
   uint16 Types[];
      [Description (
	  "Indicates the maximum number of nodes that may participate in "
	  "the Cluster.  If unlimited, enter 0.")
      ]
   uint32 MaxNumberOfNodes;  
      [Description (
	  "Indicates the state of the Cluster.  The cluster can be "
	  "defined to be on-line (value=2), off-line (3), in a degraded "
	  "mode of operation (4) or unavailable (5)."),
       Values {"Unknown", "Other", "On-line", "Off-line", 
	       "Degraded", "Unavailable"}
      ]
   uint16 ClusterState;
};

// ===================================================================
// ParticipatingCS
// ===================================================================
   [Association, 
    Description (
	 "A Cluster is composed of two or more ComputerSystems, "
	 "operating together. A ComputerSystem may participate in "
	 "multiple Clusters. \n\n"
	 "When first establishing or bringing up a Cluster, only one "
	 "ComputerSystem may be defined as participating in it. "
	 "Therfore, the cardinality of the association for "
	 "the ComputerSystem reference is Min(1). ")
   ] 
class CIM_ParticipatingCS : CIM_Dependency 
{ 
      [Override ("Antecedent"), 
	 Description ( 
	  "The ComputerSystem which participates in the Cluster. "), 
	 Min (1) 
	] 
   CIM_ComputerSystem REF Antecedent; 
	[Override ("Dependent"), 
	 Description ("The Cluster.") 
	] 
   CIM_Cluster REF Dependent;
      [Description (
	  "StateOfNode indicates the condition of the participating "
	  "ComputerSystem in the Cluster.  For example, one value is "
	  "\"Joining\" (2)."),
       Values {"Unknown", "Other", "Joining", "Paused", 
	       "Available", "Unavailable", "Degraded"}
      ] 
   uint16 StateOfNode;
      [Description (
     "RoleOfNode indicates whether the Cluster nodes are "
     "peers (value = 2), connected in a master-slave/primary-"
     "secondary relationship (values = 3 for primary, 4 for "
     "secondary), available in a standby configuration (5) or "
     "of some other (1) or unknown (0) relationship. In a "
     "System/390 environment, the nodes are identified as \"Base "
        "Plex\" (value=6) or \"Enhanced Plex\" (value=7)."),
       Values {"Unknown", "Other", "Peer", "Primary", 
	       "Secondary", "Standby", "Base Plex", "Enhanced Plex"}
      ] 
   uint16 RoleOfNode;
};

// ===================================================================
// ClusteringService
// ===================================================================
   [Description (
       "ClusteringService represents the functionality provided by a "
       "Cluster. For example, failover functionality may be modeled as "
       "a Service of a failover Cluster.")
   ]
class CIM_ClusteringService : CIM_Service
{
      [Description ( 
	  "AddNode brings a new ComputerSystem into a Cluster. "
	  "The node to be added is specified as a parameter to the "
	  "method. The return value should be 0 if the Computer"
	  "System is successfully added, 1 if the method is not "
	  "supported and any other number if an error occurred. "
        "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 AddNode ([IN] CIM_ComputerSystem ref CS);
      [Description (
	  "EvictNode removes a ComputerSystem from a Cluster. "
	  "The node to be evicted is specified as a parameter to the "
	  "method. The return value should be 0 if the ComputerSystem "
	  "is successfully evicted, 1 if the method is not supported "
	  "and any other number if an error occurred. 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 EvictNode ([IN] CIM_ComputerSystem ref CS);
};

// ===================================================================
// ClusteringSAP
// ===================================================================
   [Description (
       "A representation of the access points of a ClusteringService.")
   ]
class CIM_ClusteringSAP : CIM_ServiceAccessPoint
{
};

// ===================================================================
// ClusterServiceAccessBySAP
// ===================================================================
   [Association,
    Description (
       "ClusterServiceAccessBySAP is the relationship between a "
       "ClusteringService and its access points.")
   ]
class CIM_ClusterServiceAccessBySAP : CIM_ServiceAccessBySAP
{
      [Override ("Antecedent"),
       Description ("The ClusteringService.")       
      ]
   CIM_ClusteringService REF Antecedent;
      [Override ("Dependent"),
       Description ("An access point for the ClusteringService.")
      ]
   CIM_ClusteringSAP REF Dependent;
};

// ===================================================================
// HostedClusterService
// ===================================================================
   [Association,
    Description (
       "HostedClusterService defines the hosting Cluster for a "
       "ClusteringService.  Since this relationship is subclassed "
       "from HostedService, it inherits the scoping/naming scheme "
       "defined for Service - where a Service is weak to its "
       "hosting System.  In this case, a ClusteringService must be "
       "weak to its hosting Cluster System.")
   ]
class CIM_HostedClusterService : CIM_HostedService
{
      [Override ("Antecedent"), 
	 Description ("The Cluster.")
      ]
   CIM_Cluster REF Antecedent;
      [Override ("Dependent"), 
	 Description (
	  "The ClusteringService that is hosted on the Cluster.")
      ]
   CIM_ClusteringService REF Dependent;
};

// ===================================================================
// HostedClusterSAP
// ===================================================================
   [Association,
    Description (
       "HostedClusterSAP defines the hosting ComputerSystem for a "
       "ClusteringSAP. Since this relationship is subclassed "
       "from HostedAccessPoint, it inherits the scoping/naming scheme "
       "defined for AccessPoint - where an AccessPoint is weak to "
       "its hosting System.  In this case, a ClusteringSAP must be "
       "weak to its hosting ComputerSystem.")
   ]
class CIM_HostedClusterSAP : CIM_HostedAccessPoint
{
      [Override ("Antecedent"), 
	 Description ("The ComputerSystem.")
      ]
   CIM_ComputerSystem REF Antecedent;
      [Override ("Dependent"),
	 Description (
	  "The ClusteringSAP that is hosted on the ComputerSystem.")
      ]
   CIM_ClusteringSAP REF Dependent;
};

// ===================================================================
// BootService
// ===================================================================
   [Description (
       "BootService represents the functionality provided by a Device, "
       "software or via a Network to load an Operating System on a "
       "UnitaryComputerSystem.")
   ]
class CIM_BootService : CIM_Service
{
};

// ===================================================================
// BootSAP
// ===================================================================
   [Description (
       "A representation of the access points of a BootService.")
   ]
class CIM_BootSAP : CIM_ServiceAccessPoint
{
};

// ===================================================================
// BootServiceAccessBySAP
// ===================================================================
   [Association,
    Description (
       "BootServiceAccessBySAP is the relationship between a Boot"
       "Service and its access points.")
   ]
class CIM_BootServiceAccessBySAP : CIM_ServiceAccessBySAP
{
      [Override ("Antecedent"), 
       Description ("The BootService.")
      ]
   CIM_BootService REF Antecedent;
      [Override ("Dependent"),
       Description ("An access point for the BootService.")
      ]
   CIM_BootSAP REF Dependent;
};

// ===================================================================
// HostedBootService
// ===================================================================
   [Association,
    Description (
       "HostedBootService defines the hosting System for a Boot"
	 "Service. Since this relationship is subclassed from Hosted"
	 "Service, it inherits the scoping/naming scheme defined for "
	 "Service - where a Service is weak to its hosting System.")
   ]
class CIM_HostedBootService : CIM_HostedService
{
      [Override ("Dependent"), 
       Description ("The BootService hosted on the System.")
      ]
   CIM_BootService REF Dependent;
};

// ===================================================================
// HostedBootSAP
// ===================================================================
   [Association,
    Description (
       "HostedBootSAP defines the hosting UnitaryComputerSystem for "
       "a BootSAP. Since this relationship is subclassed from "
	 "HostedAccessPoint, it inherits the scoping/naming scheme "
	 "defined for AccessPoint - where an AccessPoint is weak to its "
	 "hosting System.  In this case, a BootSAP must be "
	 "weak to its hosting UnitaryComputerSystem.")
   ]
class CIM_HostedBootSAP : CIM_HostedAccessPoint
{
      [Override ("Antecedent"), 
       Description ("The UnitaryComputerSystem.")
      ]
   CIM_UnitaryComputerSystem REF Antecedent;
      [Override ("Dependent"), 
       Description ("The BootSAP hosted on the UnitaryComputerSystem.")
      ]
   CIM_BootSAP REF Dependent;
};

// ===================================================================
// StorageLibrary
// ===================================================================
   [Description (
       "A StorageLibrary is a collection of ManagedSystemElements "
       "that operate together to provide cartridge library "
       "capabilities. This object serves as an aggregation point to "
       "group the following elements: MediaTransferDevices, a Label"
       "Reader, a library Door, MediaAccessDevices, and other "
       "Library components.")
   ]
class CIM_StorageLibrary : CIM_System
{
      [Description (
        "Capabilities of the StorageLibrary. For example, it can be "
        "indicated that the Library can perform automatic cleaning of "
        "the MediaAccessDevices contained in it (value=1) or that the "
        "Library provides physical door access for an operator "
        "(value=2)."),
       Values {"Unknown", "Other", "Automatic Cleaning", 
             "Manual Operation", "Front Panel Lockable"}
      ]
   uint16 Capabilities[];
      [Description (
        "Boolean set to TRUE if there are more PhysicalMedia in a "
        "Library than there are StorageMediaLocations to contain them. "
        "For instance, if all MediaAccessDevices have a Media loaded "
        "in them, and all StorageMediaLocations are loaded by an "
        "operator, then an Overfilled condition exists.")
      ]
   boolean Overfilled;
      [Description (
        "Boolean set to TRUE if the Library can not currently report "
        "the correct state of each PhysicalMedia within its proper "
        "StorageMediaLocation.")
      ]
   boolean AuditNeeded;
      [Description (
        "Boolean set to TRUE if an audit of the location of some or "
        "all of the Library's PhysicalMedia is currently being "
        "performed. That an individual Changer is currently doing an "
        "audit is indicated by a similar AuditInProgress boolean "
        "property on the Changer object.")
      ]
   boolean AuditInProgress;
      [Description (
        "Maximum time in seconds that it takes for the Storage"
        "Library to perform a complete audit of each StorageMedia"
        "Location, to determine the absence or presence of a Physical"
        "Media. If automated support is not provided, then this "
        "property's value is undefined."),
       Units ("Seconds")
      ]
   uint64 MaxAuditTime;
      [Description (
        "Boolean set to TRUE if the Library includes a robotics "
        "mechanism that can be controlled by a ComputerSystem, to "
        "automatically load and unload PhysicalMedia to/from "
        "MediaAccessDevices and StorageMediaLocations. The "
        "property is set to FALSE if the Library represents a "
        "repository of Media that are inaccessible to a MediaAccess"
        "Device without human intervention. An example of a non-"
        "automated Library is a 'shelf' or 'vault' where Physical"
        "Media are kept for extended periods of time.")
      ]
   boolean Automated;
      [Description (
        "Requests that the Library robotics be enabled for "
        "automated operation (input parameter, Enabled, set to TRUE), "
        "or disabled for manual operation (input parameter set to "
        "FALSE). The return value should be 0 if the request was "
        "successfully executed, 1 if the request is not supported "
        "and some other value if an error occurred. 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 EnableRobotics([IN] boolean Enable);
};

// ===================================================================
// OperatingSystem
// ===================================================================
   [Description (
       "An OperatingSystem is software/firmware that makes a "
       "ComputerSystem's hardware usable, and implements and/or "
       "manages the resources, file systems, processes, user "
       "interfaces, services, ... available on the ComputerSystem.")
   ] 
class CIM_OperatingSystem : CIM_LogicalElement
{
      [Propagated ("CIM_ComputerSystem.CreationClassName"),
       Key,
       Description ("The scoping ComputerSystem's CreationClassName."),
       MaxLen (256)	
      ]
   string CSCreationClassName;
      [Propagated ("CIM_ComputerSystem.Name"), 
       Key,
       Description ("The scoping ComputerSystem's Name."), 
       MaxLen (256)
      ]
   string CSName;
      [Key,
       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."),
       MaxLen (256)
      ]
   string CreationClassName;
      [Override ("Name"),
       Key,
       Description (
	  "The inherited Name serves as key of an OperatingSystem "
	  "instance within a ComputerSystem."),
       MaxLen (256),
       MappingStrings {"MIF.DMTF|Operating System|001.2"}
      ]
   string Name;
      [Description (
	  "A integer indicating the type of OperatingSystem."),
       Values {"Unknown", "Other", "MACOS", "ATTUNIX", "DGUX",
             "DECNT", "Digital Unix", "OpenVMS", "HPUX", "AIX",
             "MVS", "OS400", "OS/2", "JavaVM", "MSDOS", "WIN3x",
	       "WIN95", "WIN98", "WINNT", "WINCE", "NCR3000",
             "NetWare", "OSF", "DC/OS", "Reliant UNIX",
             "SCO UnixWare", "SCO OpenServer", "Sequent",
             "IRIX", "Solaris", "SunOS", "U6000", "ASERIES",
             "TandemNSK", "TandemNT", "BS2000", "LINUX",
             "Lynx", "XENIX", "VM/ESA", "Interactive UNIX",
             "BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd", "OS9",
             "MACH Kernel", "Inferno", "QNX", "EPOC", "IxWorks",
             "VxWorks", "MiNT", "BeOS", "HP MPE", "NextStep",
             "PalmPilot", "Rhapsody", "Windows 2000", "Dedicated",
             "OS/390", "VSE", "TPF"},
	 ModelCorrespondence {
	       "CIM_OperatingSystem.OtherTypeDescription"}
      ]
   uint16 OSType;
      [Description (
	  "A string describing the manufacturer and OperatingSystem "
	  "type - used when the OperatingSystem property, OSType, is "
	  "set to 1 or 59 (\"Other\" or \"Dedicated\"). The format of "
        "the string inserted in OtherTypeDescription should be "
        "similar in format to the Values strings defined for OSType. "
        "OtherTypeDescription should be set to NULL when OSType is "
        "any value other than 1 or 59."),
	 MaxLen (64),
	 ModelCorrespondence {"CIM_OperatingSystem.OSType"}
	]
   string OtherTypeDescription;
      [Description(
	  "A string describing the Operating System's version "
	  "number. The format of the version information is as follows: "
	  "<Major Number>.<Minor Number>.<Revision> or "
	  "<Major Number>.<Minor Number>.<Revision Letter>."),
       MappingStrings {"MIF.DMTF|Operating System|001.3"}
      ]
   string Version;
      [Description ("Time when the OperatingSystem was last booted."),
       MappingStrings {"MIF.DMTF|General Information|001.5"}
      ]
   datetime LastBootUpTime; 
      [Description (
	  "OperatingSystem's notion of the local date and time of day."),
       MappingStrings {"MIB.IETF|HOST-RESOURCES-MIB.hrSystemDate",
             "MIF.DMTF|General Information|001.6"}
      ]
   datetime LocalDateTime;
      [Description (
	  "CurrentTimeZone indicates the number of minutes the "
	  "OperatingSystem is offset from Greenwich Mean Time. "
	  "Either the number is positive, negative or zero."),
       Units("Minutes")
      ] 
   sint16 CurrentTimeZone;
      [Description (
	 "Number of user licenses for the OperatingSystem. "
	 "If unlimited, enter 0.")
      ]
   uint32 NumberOfLicensedUsers;
      [Description (
	  "Number of user sessions for which the OperatingSystem is "
	  "currently storing state information."), Gauge,
       MappingStrings {"MIF.DMTF|Host System|001.4", 
	       "MIB.IETF|HOST-RESOURCES-MIB.hrSystemNumUsers"}
      ]
   uint32 NumberOfUsers;
      [Description (
	  "Number of process contexts currently loaded or running on "
	  "the OperatingSystem."), Gauge, 
       MappingStrings {"MIF.DMTF|Host System|001.5", 
	       "MIB.IETF|HOST-RESOURCES-MIB.hrSystemProcesses"}
      ]
   uint32 NumberOfProcesses;
      [Description (
	  "Maximum number of process contexts the OperatingSystem can "
	  "support. If there is no fixed maximum, the value should be 0."
	  "On systems that have a fixed maximum, this object can help "
	  "diagnose failures that occur when the maximum is reached."), 
       MappingStrings {"MIF.DMTF|Host System|001.6", 
	       "MIB.IETF|HOST-RESOURCES-MIB.hrSystemMaxProcesses"}
      ]
   uint32 MaxNumberOfProcesses;
      [Description (
	  "Total swap space in Kbytes. This value may be "
	  "NULL (unspecified) if swap space is not distinguished from "
	  "page files.  However, some Operating Systems distinguish "
	  "these concepts.  For example, in UNIX, whole processes can be "
	  "'swapped out' when the free page list falls and remains "
	  "below a specified amount."),
       Units("KiloBytes")
      ]
   uint64 TotalSwapSpaceSize;
      [Description (
	  "Number of Kbytes of virtual memory. For example, "
	  "this may be calculated by adding the amount of total RAM to "
	  "the amount of paging space (ie, adding the amount of "
	  "memory in/aggregated by the ComputerSystem to the property, "
	  "SizeStoredInPagingFiles."),
       MappingStrings {"MIF.DMTF|System Memory Settings|001.5"},
       Units("KiloBytes")
      ]
   uint64 TotalVirtualMemorySize;
      [Gauge, Description (
	  "Number of Kbytes of virtual memory currently unused and "
	  "available. For example, this may be calculated by adding "
	  "the amount of free RAM to the amount of free paging space "
	  "(ie, adding the properties, FreePhysicalMemory and FreeSpace"
	  "InPagingFiles)."),
       MappingStrings {"MIF.DMTF|System Memory Settings|001.6"},
       Units("KiloBytes")
      ]
   uint64 FreeVirtualMemory;
      [Gauge, Description (
	  "Number of Kbytes of physical memory currently unused and "
	  "available."),
       MappingStrings {"MIF.DMTF|System Memory Settings|001.2"},
       Units("KiloBytes")
      ]
   uint64 FreePhysicalMemory;
      [Description (
        "The total amount of physical memory (in Kbytes) available "
        "to the OperatingSystem. This value does not necessarily "
        "indicate the true amount of physical memory, but what is "
        "reported to the OperatingSystem as available to it."),
       Units("KiloBytes")
      ]
   uint64 TotalVisibleMemorySize;
      [Description (
	  "The total number of KBytes that can be stored in the "
	  "OperatingSystem's paging files. 0 indicates that there "
	  "are no paging files."),
       Units("KiloBytes"),
       MappingStrings {"MIF.DMTF|System Memory Settings|001.3"}
      ]
   uint64 SizeStoredInPagingFiles;
      [Gauge, Description (
	  "The total number of KBytes that can be mapped into the "
	  "OperatingSystem's paging files without causing any other "
	  "pages to be swapped out. 0 indicates that there are no "
	  "paging files."),
       Units("KiloBytes"),
       MappingStrings {"MIF.DMTF|System Memory Settings|001.4"}
      ]
   uint64 FreeSpaceInPagingFiles;
	[Description (
   	  "Maximum number of Kbytes of memory that can be allocated "
	  "to a Process. For Operating Systems with no virtual memory, "
	  "this value is typically equal to the total amount of "
	  "physical Memory minus memory used by the BIOS and OS. For "
	  "some Operating Systems, this value may be infinity - in "
	  "which case, 0 should be entered. In other cases, this value "
	  "could be a constant - for example, 2G or 4G."),
   	 Units("KiloBytes")
	]
   uint64 MaxProcessMemorySize;
      [Description (
	  "Boolean indicating whether the OperatingSystem is "
	  "distributed across several ComputerSystem nodes. If so, "
	  "these nodes should be grouped as a Cluster.")
      ]
   boolean Distributed;
      [Description (
	  "Requests a reboot of the OperatingSystem. The return value "
	  "should be 0 if the request was successfully executed, "
	  "1 if the request is not supported and some other value "
	  "if an error occurred. 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 Reboot();
      [Description (
	  "Requests a shutdown of the OperatingSystem. The return "
	  "value should be 0 if the request was successfully executed, "
	  "1 if the request is not supported and some other value if "
	  "an error occurred. It is up to the implementation or subclass "
	  "of OperatingSystem to establish dependencies between "
	  "the Shutdown and Reboot methods, and for example, to provide "
	  "more sophisticated capabilities such as scheduled shutdown/"
	  "reboot, etc. 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 Shutdown();
};

// ===================================================================
// InstalledOS
// ===================================================================
   [Association,
    Aggregation,
    Description (
       "A link between the ComputerSystem and the OperatingSystem(s) "
       "installed or loaded on it. An OperatingSystem is 'installed' "
       "on a ComputerSystem, when placed on one of its StorageExtents "
       "- for example, copied to a disk drive or downloaded to "
       "Memory. Using this definition, an OperatingSystem is "
       "'installed' on a NetPC when downloaded via the network.")
   ] 
class CIM_InstalledOS : CIM_SystemComponent
{
      [Override ("GroupComponent"),
       Aggregate,
       Description ("The ComputerSystem."),
       Min(1), Max (1)
      ]
   CIM_ComputerSystem REF GroupComponent;
      [Override ("PartComponent"),
       Description (
	  "The OperatingSystem installed on the ComputerSystem."),
       Weak
      ]
   CIM_OperatingSystem REF PartComponent;
      [Description (
	  "Boolean indicating that the OperatingSystem is the default "
	  "OS for the ComputerSystem."),
       MappingStrings {"MIF.DMTF|Operating System|001.4"}
      ]
   boolean PrimaryOS;
};

// ===================================================================
// RunningOS
// ===================================================================
   [Association,
    Description (
       "RunningOS indicates the currently executing OperatingSystem. "
       "At most one OperatingSystem can execute at any time on a "
       "ComputerSystem. 'At most one' is specified, since the Computer"
       "System may not be currently booted, or its OperatingSystem "
       "may be unknown.")
   ] 
class CIM_RunningOS : CIM_Dependency
{
      [Override ("Antecedent"),
       Description (
	  "The OperatingSystem currently running on the "
	  "ComputerSystem."),
       Max (1)
      ]
   CIM_OperatingSystem REF Antecedent;
      [Override ("Dependent"), 
       Description ("The ComputerSystem."),
       Max (1)
      ]
   CIM_ComputerSystem REF Dependent;
};

// ==================================================================
// OperatingSystemSoftwareFeature
// ==================================================================
   [Association, Aggregation,
    Description (
       "Indicates the SoftwareFeatures that make up the Operating"
       "System. The SoftwareFeatures can be part of different "
       "Products.")
   ] 
class CIM_OperatingSystemSoftwareFeature : CIM_Component
{
	  [Override ("GroupComponent"), Aggregate,
	   Description ("The OperatingSystem.")
	  ]
    CIM_OperatingSystem REF GroupComponent;
        [Override ("PartComponent"),
	   Description (
	    "The SoftwareFeatures that make up the OperatingSystem.")
        ]
    CIM_SoftwareFeature REF PartComponent;
};

// ===================================================================
// FileSystem
// ===================================================================
   [Description (
       "A file or dataset store local to a ComputerSystem or "
       "remotely mounted from a file server.")
   ] 
class CIM_FileSystem : CIM_LogicalElement
{
      [Propagated ("CIM_ComputerSystem.CreationClassName"),
       Key,
       Description ("The scoping ComputerSystem's CreationClassName."),
       MaxLen (256)
      ]
   string CSCreationClassName;
      [Propagated ("CIM_ComputerSystem.Name"),
       Key,
       Description ("The scoping ComputerSystem's Name."),
       MaxLen (256)
      ]
   string CSName;
      [Key,
       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."),
       MaxLen (256)
      ]
   string CreationClassName;
      [Override ("Name"),
       Key,
       Description (
	  "The inherited Name serves as key of a FileSystem instance "
	  "within a ComputerSystem."),
       MaxLen (256)
      ]
   string Name;
      [Description (
	  "Path name or other information defining the root of the "
	  "FileSystem."),
       MappingStrings {"MIB.IETF|HOST-RESOURCES-MIB.hrFSMountPoint", 
             "MIF.DMTF|Host File System|001.2"}
      ]
   string Root;
      [Description (
	  "FileSystems can read/write data in blocks which are defined "
	  "independently of the underlying StorageExtents. This property "
	  "captures the FileSystem's block size for data storage and "
	  "retrieval."),
       Units("Bytes")
      ]
   uint64 BlockSize;
      [Description (
	  "The FileSystemSize property stores the total size of the File"
	  "System in bytes. If unknown, enter 0."),
       Units("Bytes"), 
       MappingStrings {"MIF.DMTF|Host File System|001.13"}
      ]
   uint64 FileSystemSize;
      [Gauge, Description (
	  "AvailableSpace indicates the total amount of free space "
	  "for the FileSystem, in bytes. If unknown, enter 0."),
       Units("Bytes"), 
       MappingStrings {"MIF.DMTF|Host File System|001.14", 
             "MIF.DMTF|Partition|002.4"}
      ]
   uint64 AvailableSpace;
      [Description (
	  "Indicates that the FileSystem is designated as read only."),
       MappingStrings {"MIB.IETF|HOST-RESOURCES-MIB.hrFSAccess", 
             "MIF.DMTF|Host File System|001.5"}
      ] 
   boolean ReadOnly;
      [Description (
	  "A free form string indicating the algorithm or tool used to "
	  "encrypt the FileSystem. If it is not possible or not desired "
	  "to describe the encryption scheme (perhaps for security "
	  "reasons), recommend using the following words: \"Unknown\" to "
	  "represent that it is not known whether the FileSystem is "
	  "encrypted or not, \"Encrypted\" to represent that the File"
	  "System is encrypted but either its encryption scheme is not "
	  "known or not disclosed, and \"Not Encrypted\" to represent "
	  "that the FileSystem is not encrypted."),
       MappingStrings {"MIF.DMTF|Partition|002.8"}
      ]
   string EncryptionMethod;
      [Description (
	  "A free form string indicating the algorithm or tool used to "
	  "compress the FileSystem. If it is not possible or not desired "
	  "to describe the compression scheme (perhaps because it is not "
	  "known), recommend using the following words: \"Unknown\" to "
	  "represent that it is not known whether the FileSystem is "
	  "compressed or not, \"Compressed\" to represent that the File"
	  "System is compressed but either its compression scheme is not "
	  "known or not disclosed, and \"Not Compressed\" to represent "
	  "that the FileSystem is not compressed."),
       MappingStrings {"MIF.DMTF|Partition|002.7"}
      ]
   string CompressionMethod;
      [Description (
	  "Indicates that case sensitive file names are supported.")
      ]
   boolean CaseSensitive;
      [Description (
	  "Indicates that the case of file names are preserved.")
      ]
   boolean CasePreserved;
      [Description (
	  "Array defining the character sets or encoding supported by "
        "the FileSystem. For example, the values, \"ASCII\" (2) or "
        "\"ISO2022\" (4), may be specified."),
       Values {"Unknown", "Other", "ASCII", "Unicode", 
	       "ISO2022", "ISO8859", "Extended UNIX Code", "UTF-8",
             "UCS-2"}
      ]
   uint16 CodeSet[];
      [Description (
	  "Integer indicating the maximum length of a file name within "
	  "the FileSystem. 0 indicates that there is no limit on file "
	  "name length.")
      ]
   uint32 MaxFileNameLength;
      [Description (
        "The minimum file allocation size (an integral number of "
        "blocks), imposed by the FileSystem. (The size of a block is "
        "specified in the BlockSize property for the FileSystem.) "
        "Minimum allocation size is the smallest amount of storage "
        "allocated to a LogicalFile by the FileSystem. This is not a "
        "mandatory minimum allocation for all FileSystems. Under "
        "stress conditions, some FileSystems may allocate storage "
        "in amounts smaller than the ClusterSize.")
      ]
   uint32 ClusterSize;
      [Description (
        "String describing the type of FileSystem and therefore, its "
        "conventions. For example, \"NTFS\" or \"S5\" may be listed "
        "as well as any additional information on the FileSystem's "
        "implementation. Since various flavors of FileSystems (like "
        "S5) exist, this property is defined as a string."),
       MappingStrings {"MIF.DMTF|Partition|002.6", 
             "MIF.DMTF|Host File System|001.4"}
      ]
string FileSystemType;
};

// ===================================================================
// LocalFileSystem
// ===================================================================
   [Description (
		"A class derived from FileSystem that represents the file " 
		"store controlled by a ComputerSystem through local means " 
		"(e.g., direct device driver access). In this case, the " 
		"file store is managed directly by the ComputerSystem " 
		"without the need for another computer to act as a " 
		"file server. This definition does not breakdown in the " 
		"case of a Clustered File System. In this scenario, the " 
		"FileSystem is a LocalFileSystem, weak to the Cluster.")
   ] 
class CIM_LocalFileSystem : CIM_FileSystem
{
};

// ===================================================================
// RemoteFileSystem
// ===================================================================
   [Description (
		"A class derived from FileSystem that represents access of the " 
		"FileSystem via a network-related service. In this case, the " 
		"file store is hosted by a computer, acting as a file server. " 
		"For example, the file store for an NFS FileSystem is typically " 
		"NOT on a ComputerSystem's locally controlled media, nor is " 
		"it directly accessed through a device driver. Subclasses of " 
		"RemoteFileSystem contain client-side configuration information " 
		"related to the access of the FileSystem.")
   ] 
class CIM_RemoteFileSystem : CIM_FileSystem
{
};

// ===================================================================
// NFS (NetworkFileSystem)
// ===================================================================
   [Description (
		"A class derived from RemoteFileSystem representing that " 
		"the FileSystem is mounted, using the NFS protocol, from " 
		"a ComputerSystem. The properties of the NFS object " 
		"deal with the operational aspects of the mount and represent " 
		"the client-side configuration for NFS access. The " 
		"FileSystemType (inherited from FileSystem) should be set " 
		"to indicate the type of this FileSystem as it appears to " 
		"the client.")
   ] 
class CIM_NFS : CIM_RemoteFileSystem
{
      [Description (
	  "If set to true: Once the FileSystem is mounted, NFS requests "
	  "are retried until the hosting System responds.\n" 
	  "If set to false: Once the FileSystem is mounted, an error "
	  "is returned if the hosting System does not respond.")
      ]
   boolean HardMount;
      [Description (
	  "If set to true: Retries are performed in the foreground.\n"
	  "If set to false: If the first mount attempt fails, retries "
	  "are performed in the background.")
      ]
   boolean ForegroundMount;
      [Description (
	  "If set to true: Interrupts are permitted for hard mounts.\n"
	  "If set to false: Interrupts are ignored for hard mounts.")
      ]
   boolean Interrupt;
      [Description ("Maximum number of mount failure retries allowed.")]
   uint16 MountFailureRetries;
      [Description ("Maximum number of NFS retransmissions allowed.")]
   uint16 RetransmissionAttempts;
      [Description ("NFS timeout in tenths of a second."),
       Units ("Tenths of Seconds")
      ]
   uint32 RetransmissionTimeout;
      [Description ("Read buffer size in bytes."),
       Units("Bytes")
      ]
   uint64 ReadBufferSize;
      [Description ("Write buffer size in bytes."),
       Units("Bytes")
      ]
   uint64 WriteBufferSize;
      [Description (
	  "The remote ComputerSystem's (ie, the NFS File "
	  "'Server's) UDP port number.")
      ]
   uint32 ServerCommunicationPort;
      [Description (
	  "If set to true: Control attribute caching is enabled.\n"
	  "If set to false: Control attribute caching is disabled.")
      ]
   boolean AttributeCaching;
      [Description (
	  "Minimum number of seconds that cached attributes are held "
	  "after file modification."),
       Units("Seconds")
      ]
   uint16 AttributeCachingForRegularFilesMin;
      [Description (
	  "Maximum number of seconds that cached attributes are held "
	  "after file modification."),
       Units("Seconds")
      ]
   uint16 AttributeCachingForRegularFilesMax;
      [Description (
	  "Minimum number of seconds that cached attributes are held "
	  "after directory update."),
       Units("Seconds")
      ]
   uint16 AttributeCachingForDirectoriesMin;
      [Description (
	  "Maximum number of seconds that cached attributes are held "
	  "after directory update."),
       Units("Seconds")
      ]
   uint16 AttributeCachingForDirectoriesMax;
};

// ===================================================================
// LogicalFile
// ===================================================================
   [Description (
       "A LogicalFile is a named collection of data or executable "
       "code, or represents a LogicalDevice or Directory.  It is "
	 "located within the context of a FileSystem, on a Storage"
	 "Extent.")
   ] 
class CIM_LogicalFile : CIM_LogicalElement
{
      [Propagated ("CIM_FileSystem.CSCreationClassName"),
       Key,
       Description ("The scoping ComputerSystem's CreationClassName."),
       MaxLen (256)
      ]
   string CSCreationClassName;
      [Propagated ("CIM_FileSystem.CSName"),
       Key,
       Description ("The scoping ComputerSystem's Name."),
       MaxLen (256)
      ]
   string CSName;
      [Propagated ("CIM_FileSystem.CreationClassName"), 
       Key,
       Description ("The scoping FileSystem's CreationClassName."),
       MaxLen (256)
      ]
   string FSCreationClassName;
      [Propagated ("CIM_FileSystem.Name"),
       Key,
       Description ("The scoping FileSystem's Name."),
       MaxLen (256)
      ]
   string FSName;
      [Key,
       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."),
       MaxLen (256)
      ]
   string CreationClassName;	
      [Override ("Name"),
       Key,
       Description (
	  "The inherited Name serves as key of a LogicalFile instance "
	  "within a FileSystem. Full path names should be provided if "
	  "a Directory hierarchy is not modeled or does not exist. In "
	  "all cases, the LogicalFile's Name property must be unique "
	  "for all instances within a single FileSystem and "
	  "creation class."),
       MaxLen (1024)
      ]
   string Name;
      [Gauge, Description ("Size of the File in bytes."),
       Units ("Bytes")
      ] 
   uint64 FileSize;
      [Description ("File's creation date.")] 
   datetime CreationDate;
      [Description ("Time that the File was last modified.")] 
   datetime LastModified;
      [Description ("Time that the File was last accessed.")] 
   datetime LastAccessed;
      [Description ("Boolean indicating that the File can be read.")] 
   boolean Readable;
      [Description (
	  "Boolean indicating that the File can be written.")
      ] 
   boolean Writeable;
      [Description (
	  "A free form string indicating the algorithm or tool used to "
	  "compress the LogicalFile. If it is not possible or not "
	  "desired to describe the compression scheme (perhaps because "
	  "it is not known), recommend using the following words: "
	  "\"Unknown\" to represent that it is not known whether the "
	  "LogicalFile is compressed or not, \"Compressed\" to "
	  "represent that the File is compressed but either its "
	  "compression scheme is not known or not disclosed, and \"Not "
	  "Compressed\" to represent that the LogicalFile is not "
	  "compressed.")
      ] 
   string CompressionMethod;
      [Description (
	  "A free form string indicating the algorithm or tool used to "
	  "encrypt the LogicalFile. If it is not possible or not desired "
	  "to describe the encryption scheme (perhaps for security "
	  "reasons), recommend using the following words: \"Unknown\" to "
	  "represent that it is not known whether the LogicalFile is "
	  "encrypted or not, \"Encrypted\" to represent that the File "
	  "is encrypted but either its encryption scheme is not known "
	  "or not disclosed, and \"Not Encrypted\" to represent "
	  "that the LogicalFile is not encrypted.")
      ] 
   string EncryptionMethod;
      [Description (
	  "Integer indicating the number of 'file opens' that are "
	  "currently active against the File."), Counter
      ]
   uint64 InUseCount;
};

// ===================================================================
// DataFile
// ===================================================================
   [Description (
       "DataFile is a type of LogicalFile that is a named collection "
       "of data or executable code.")
   ] 
class CIM_DataFile : CIM_LogicalFile
{
};

// ===================================================================
// Directory
// ===================================================================
   [Description (
       "Directory is a type of File that logically groups Files "
       "'contained' in it, and provides path information for the "
       "grouped Files.")
   ] 
class CIM_Directory : CIM_LogicalFile
{
};

// ===================================================================
// DeviceFile
// ===================================================================
   [Description (
       "DeviceFile is a special type of LogicalFile that represents "
       "a Device. This convention is useful for some operating systems "
       "that manage devices using a byte stream I/O model. The Logical"
       "Device that is associated with this file is specified using "
       "the DeviceAccessedByFile relationship.")
   ] 
class CIM_DeviceFile : CIM_LogicalFile
{
};

// ===================================================================
// DeviceAccessedByFile
// ===================================================================
   [Association,
    Description (
       "Specifies the LogicalDevice that is associated with, and "
       "accessed using the referenced DeviceFile.")
   ] 
class CIM_DeviceAccessedByFile : CIM_Dependency
{   
      [Override ("Antecedent"),
       Description ("The DeviceFile.")
      ]
   CIM_DeviceFile REF Antecedent;
      [Override ("Dependent"),
       Description (
	  "The Device that is accessed using the DeviceFile."),
       Max (1)
      ]
   CIM_LogicalDevice REF Dependent;
};

// ===================================================================
// DirectoryContainsFile
// ===================================================================
   [Association,
    Aggregation,
    Description (
       "Specifies the hierarchical arrangement of LogicalFiles in a "
       "Directory.")
   ] 
class CIM_DirectoryContainsFile : CIM_Component
{   
      [Override ("GroupComponent"),
       Aggregate,
       Description ("The Directory."),
       Max (1)
      ]
   CIM_Directory REF GroupComponent;
      [Override ("PartComponent"),
       Description ("The LogicalFile 'contained within' the Directory.")
      ]
   CIM_LogicalFile REF PartComponent;
};

// ===================================================================
// Mount
// ===================================================================
	    [Association,  Description ( 
		"An association between a FileSystem and a Directory "
		"which indicates that the Directory is being attached to "
		"the FileSystem. The semantics of this relationship require "
		"that the mounted Directory be contained by a FileSystem "
		"(via the FileStorage association) that is different from "
		"the FileSystem referenced as the Dependent. The "
		"Directory's containing FileSystem could be either " 
		"local or remote. For example, a LocalFileSystem on a Solaris " 
		"ComputerSystem can mount a Directory from the FileSystem "
		"accessed via the machine's CDROM drive, i.e., another LocalFile"
		"System. On the other hand, in a 'remote' case, the Directory "
		"is first exported by its FileSystem, which is hosted on another "
		"ComputerSystem acting (for example) as a file server. In order to "
		"distinguish these two types of Mount, it is recommended that "
		"a CIM_Export association always be defined for the remotely "
		"accessed/mounted Directories.") ]
class CIM_Mount : CIM_Dependency 
{ 
		[Override ("Antecedent"), 
		 Description ("The Directory mounted."), 
		 Max (1) 
		] 
	CIM_Directory REF Antecedent; 
		[Override ("Dependent"), 
		 Description ("The FileSystem the Directory is mounted on.") 
		]  
	CIM_FileSystem REF Dependent; 
};

// ===================================================================
// Export
// ===================================================================
	[Association, 
	Description ( 
	"An association between a LocalFileSystem and its Directories " 
	"indicating that the specified Directories are available for " 
	"mount. When exporting an entire FileSystem, the Directory " 
	"should reference the topmost directory of the FileSystem.") 
	] 
class CIM_Export 
{ 
		[Key, Description ("The LocalFileSystem."), 
		Max (1) 
		] 
	CIM_LocalFileSystem REF LocalFS; 
		[Key, Description ("The Directory exported for mount.")
		] 
	CIM_Directory REF Directory; 
		[Description ("Name under which the Directory is exported.")
		] 
	string ExportedDirectoryName; 
}; 

// ===================================================================
// HostedFileSystem
// ===================================================================
   [Association,
    Aggregation,
    Description (
       "A link between the ComputerSystem and the FileSystem(s) "
       "hosted on this ComputerSystem.")
   ] 
class CIM_HostedFileSystem : CIM_SystemComponent
{
      [Override ("GroupComponent"),
       Aggregate,
       Description ("The ComputerSystem."),
       Min (1), Max (1)
      ]
   CIM_ComputerSystem REF GroupComponent;
      [Override ("PartComponent"),
       Description ("The FileSystem owned by the ComputerSystem."),
       Weak
      ]
   CIM_FileSystem REF PartComponent;
};

// ===================================================================
// BootOSFromFS
// ===================================================================
   [Association,
    Description (
       "A link between the OperatingSystem and the FileSystem(s) from "
       "which this OperatingSystem is loaded. The association is many-"
       "to-many since a Distributed OS could depend on several File"
       "Systems in order to correctly and completely load.")
   ] 
class CIM_BootOSFromFS : CIM_Dependency
{
      [Override ("Antecedent"),
       Description (
	  "The FileSystem from which the OperatingSystem is loaded.")
      ]
   CIM_FileSystem REF Antecedent;
      [Override ("Dependent"),
       Description ("The OperatingSystem.")
      ]
   CIM_OperatingSystem REF Dependent;
};

// ===================================================================
// FileStorage
// ===================================================================
   [Association,
    Aggregation,
    Description (
       "A link between the FileSystem and the LogicalFile(s) addressed "
       "through this FileSystem.")
   ] 
class CIM_FileStorage : CIM_Component
{
      [Override ("GroupComponent"),
       Aggregate,
       Description ("The FileSystem."),
       Min (1), Max (1)
      ]
   CIM_FileSystem REF GroupComponent;
      [Override ("PartComponent"),
       Description (
	  "The LogicalFile stored in the context of the FileSystem."),
       Weak
      ]
   CIM_LogicalFile REF PartComponent;
};

// ===================================================================
// Process
// ===================================================================
   [Description (
       "Each instance of the CIM_Process class represents a single "
       "instance of a running program. A user of the OperatingSystem "
       "will typically see a Process as an application or task. Within "
       "an OperatingSystem, a Process is defined by a workspace of "
       "memory resources and environmental settings that are allocated "
       "to it. On a multitasking System, this workspace prevents "
       "intrusion of resources by other Processes. Additionally, a "
       "Process can execute as multiple Threads, all which run within "
       "the same workspace.")
   ] 
class CIM_Process : CIM_LogicalElement
{
      [Propagated("CIM_OperatingSystem.CSCreationClassName"),
       Key,
       Description ("The scoping ComputerSystem's CreationClassName."),
       MaxLen (256)
      ]
   string CSCreationClassName;
      [Propagated("CIM_OperatingSystem.CSName"),
       Key,
       Description ("The scoping ComputerSystem's Name."),
       MaxLen (256)
      ]
   string CSName;
      [Propagated("CIM_OperatingSystem.CreationClassName"),
       Key,
       Description ("The scoping OperatingSystem's CreationClassName."),
       MaxLen (256)
      ]
   string OSCreationClassName;
      [Propagated("CIM_OperatingSystem.Name"),
       Key,
       Description ("The scoping OperatingSystem's Name."),
       MaxLen (256)
      ]
   string OSName;
      [Key,
       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."),
       MaxLen (256)
      ]
   string CreationClassName;
      [Key,
       Description (
	  "A string used to identify the Process. A Process ID is a "
	  "kind of Process Handle."),
       MaxLen (256), 
       MappingStrings {"MIF.DMTF|Process Information|001.1"}
      ]
   string Handle;
	[Override ("Name"),
	 MappingStrings {"MIF.DMTF|Process Information|001.6"}
	]
   string Name;
      [Description (
	  "Priority indicates the urgency or importance of execution "
	  "of a Process. If a priority is not defined for a Process, "
	  "a value of 0 should be used."), 
       MappingStrings {"MIF.DMTF|Process Information|001.10"}
      ]
   uint32 Priority;
      [Description (
	  "Indicates the current operating condition of the Process. "
	  "Values include ready (2), running (3), and blocked (4), "
	  "among others."),
       Values {"Unknown", "Other", "Ready", "Running", 
	       "Blocked", "Suspended Blocked", "Suspended Ready", 
             "Terminated", "Stopped", "Growing"}, 
       MappingStrings {"MIF.DMTF|Process Information|001.9"}
      ]
   uint16 ExecutionState;
      [Description ("Time that the Process began executing.")]
   datetime CreationDate;
      [Description (
	  "Time that the Process was stopped or terminated.")
      ]
   datetime TerminationDate;
      [Description (
	  "Time in user mode, in milliseconds. If this information is "
	  "not available, a value of 0 should be used."), 
       Units("MilliSeconds"), 
       MappingStrings {"MIF.DMTF|Process Information|001.14"}
      ]
   uint64 UserModeTime;
      [Description (
	  "Time in kernel mode, in milliseconds. If this information "
	  "is not available, a value of 0 should be used."),
       Units("MilliSeconds"), 
       MappingStrings {"MIF.DMTF|Process Information|001.13"}
      ]
   uint64 KernelModeTime;
      [Gauge, Description (
	  "The amount of memory in bytes that a Process needs to execute "
	  "efficiently, for an OperatingSystem that uses page-based "
	  "memory management. If an insufficient amount of memory "
	  "is available (< working set size), thrashing will occur. "
	  "If this information is not known, NULL or 0 should be "
	  "entered.  If this data is provided, it could be monitored "
	  "to understand a Process' changing memory requirements as "
	  "execution proceeds."),
       Units ("Bytes")
	]
   uint64 WorkingSetSize;
};

// ===================================================================
// OSProcess
// ===================================================================
   [Association,
    Aggregation,
    Description (
       "A link between the OperatingSystem and Process(es) running "
       "in the context of this OperatingSystem.")
   ] 
class CIM_OSProcess : CIM_Component
{
      [Override ("GroupComponent"),
       Aggregate,
       Description ("The OperatingSystem."),
       Min (1), Max (1)
      ]
   CIM_OperatingSystem REF GroupComponent;
      [Override ("PartComponent"),
       Description (
	  "The Process running in the context of the OperatingSystem"),
       Weak
      ]
   CIM_Process REF PartComponent;
};

// ===================================================================
// ProcessExecutable
// ===================================================================
   [Association,
    Description (
       "A link between a Process and a DataFile indicating that the "
       "File participates in the execution of the Process.")
   ] 
class CIM_ProcessExecutable : CIM_Dependency
{
      [Override ("Antecedent"),
       Description (
	  "The DataFile participating in the execution of the Process.")
      ]
   CIM_DataFile REF Antecedent;
      [Override ("Dependent"),
       Description ("The Process.")
      ] 
   CIM_Process REF Dependent;
};

// ===================================================================
// Thread
// ===================================================================
   [Description (
       "Threads represent the ability to execute units of a Process "
       "or task in parallel.  A Process can have many Threads, each "
       "of which is weak to the Process.")
   ] 
class CIM_Thread : CIM_LogicalElement
{
      [Propagated("CIM_Process.CSCreationClassName"),
       Key,
       Description ("The scoping ComputerSystem's CreationClassName."),
       MaxLen (256)
      ]
   string  CSCreationClassName;
      [Propagated("CIM_Process.CSName"),
       Key,
       Description ("The scoping ComputerSystem's Name."),
       MaxLen (256)
      ]
   string CSName;
      [Propagated("CIM_Process.OSCreationClassName"),
       Key,
       Description ("The scoping OperatingSystem's CreationClassName."),
       MaxLen (256)
      ]
   string OSCreationClassName;
      [Propagated("CIM_Process.OSName"),
       Key,
       Description ("The scoping OperatingSystem's Name."),
       MaxLen (256)
      ]
   string OSName;
      [Propagated("CIM_Process.CreationClassName"),
       Key,
       Description ("The scoping Process' CreationClassName."),
       MaxLen (256)
      ]
   string ProcessCreationClassName;
      [Propagated("CIM_Process.Handle"),
       Key,
       Description ("The scoping Process' Handle."),
       MaxLen (256)
      ]
   string ProcessHandle;
      [Key,
       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 "
	  "allow all instances of this class and its subclasses to "
	  "be uniquely identified."),
       MaxLen (256)
      ]
   string CreationClassName;
      [Key,
       Description ("A string used to identify the Thread."),
       MaxLen (256)
      ]
   string Handle;
      [Description (
	  "Priority indicates the urgency or importance of execution "
	  "of a Thread. A Thread may have a different priority than "
	  "its owning Process. If this information is not available "
	  "for a Thread, a value of 0 should be used.")
      ]
   uint32 Priority;
      [Description (
	  "Indicates the current operating condition of the Thread. " 
	  "Values include ready (2), running (3), and blocked (4), "
	  "among others."),
       Values {"Unknown", "Other", "Ready", "Running", 
	       "Blocked", "Suspended Blocked", "Suspended Ready"}
      ]
   uint16 ExecutionState;
      [Description (
	  "Time in user mode, in milliseconds. If this information is "
	  "not available, a value of 0 should be used."),
       Units("MilliSeconds")
      ]
   uint64 UserModeTime;
      [Description (
	  "Time in kernel mode, in milliseconds. If this information "
	  "is not available, a value of 0 should be used."),
       Units("MilliSeconds")
      ]
   uint64 KernelModeTime;
};

// ===================================================================
// ProcessThread
// ===================================================================
   [Association,
    Aggregation,
    Description (
       "A link between a Process and the Thread(s) running in the "
       "context of this Process.")
   ] 
class CIM_ProcessThread : CIM_Component
{
      [Override ("GroupComponent"),
       Aggregate,
       Description ("The Process."),
       Min (1), Max (1)
      ]
   CIM_Process REF GroupComponent;
      [Override ("PartComponent"),
       Description (
	  "The Thread running in the context of the Process."),
       Weak
      ]
   CIM_Thread REF PartComponent;
};

// ===================================================================
// BIOSFeature
// ===================================================================
   [Description (
       "BIOSFeature represents the capabilities of the low-level "
       "software that is used to bring up and configure a Computer"
       "System.")
   ] 
class CIM_BIOSFeature : CIM_SoftwareFeature
{
      [Description (
        "An array of integers that specify the features "
        "supported by the BIOS. For example, one can specify that "
        "PnP capabilities are provided (value=9) or that infrared "
        "devices are supported (21). Values specified in the "
        "enumeration are taken from both DMI and SMBIOS (the Type 0 "
        "structure, the BIOS Characteristics and BIOS "
        "Characteristics Extension Bytes attributes."),
       ValueMap {"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", "28", "29", "30", "31", "160"},
       Values {"Other", "Unknown", "Undefined", "ISA Support", 
             "MCA Support", "EISA Support", "PCI Support", 
             "PCMCIA Support", "PnP Support", "APM Support", 
             "Upgradeable BIOS", "BIOS Shadowing Allowed", 
             "VL VESA Support", "ESCD Support", 
             "LS-120 Boot Support", "ACPI Support", 
             "I2O Boot Support", "USB Legacy Support", 
             "AGP Support", "PC Card", "IR", "1394", "I2C", 
             "Smart Battery", "ATAPI ZIP Drive Boot Support", 
             "1394 Boot Support", "Boot from CD", 
             "Selectable Boot", "BIOS ROM is Socketed", 
             "Boot from PCMCIA", "EDD Specification Support", 
             "PC-98"},
       MappingStrings {"MIF.DMTF|BIOS Characteristic|004.3"},
       ArrayType ("Indexed"),
	 ModelCorrespondence {
		 "CIM_BIOSFeature.CharacteristicDescriptions"}
      ]
   uint16 Characteristics[];
      [Description (
	  "An array of free-form strings providing more detailed "
	  "explanations for any of the BIOS features indicated in the "
	  "Characteristics array. Note, each entry of this array "
	  "is related to the entry in the Characteristics array that "
	  "is located at the same index."),
       ArrayType ("Indexed"),
       MappingStrings {"MIF.DMTF|BIOS Characteristic|004.4"},
	 ModelCorrespondence {"CIM_BIOSFeature.Characteristics"}
      ]
   string CharacteristicDescriptions[];
};
 
// ===================================================================
// BIOSElement
// ===================================================================
   [Description (
       "BIOSElement represents the low-level software that is loaded "
       "into non-volatile storage and used to bring up and configure "
       "a ComputerSystem.")
   ] 
class CIM_BIOSElement : CIM_SoftwareElement
{
      [Override ("Version"),
       MappingStrings {"MIF.DMTF|System BIOS|001.3"}
      ]
   string Version;
      [Override ("Manufacturer"),
       MappingStrings {"MIF.DMTF|System BIOS|001.2"}
      ]
   string Manufacturer;		
      [Description (
	  "If true, this is the primary BIOS of the ComputerSystem."),
       MappingStrings {"MIF.DMTF|System BIOS|001.9"}
      ]
   boolean PrimaryBIOS;
      [Description (
        "A list of installable languages for the BIOS. This "
        "information can be obtained from SMBIOS, from the string list "
        "that follows the Type 13 structure. An ISO 639 Language Name "
        "should be used to specify the BIOS' installable languages. The "
        "ISO 3166 Territory Name and the encoding method may also be "
        "specified, following the Language Name.")
      ]
   string ListOfLanguages[];
      [Description (
        "The currently selected language for the BIOS. This "
        "information can be obtained from SMBIOS, using the Current "
        "Language attribute of the Type 13 structure, to index into the "
        "string list following the structure. The property is formatted "
        "using the ISO 639 Language Name, and may be followed by the "
        "ISO 3166 Territory Name and the encoding method."),
       ModelCorrespondence {"CIM_BIOSElement.ListOfLanguages"}
      ]
   string CurrentLanguage;
   		[Description (
		"The starting address of the memory which this BIOS "
		"occupies."), 
		MappingStrings {"MIF.DMTF|System BIOS|001.5"}
		]
	uint64 LoadedStartingAddress;
		[Description (
		"The ending address of the memory which this BIOS "
		"occupies."),
		MappingStrings {"MIF.DMTF|System BIOS|001.6"}
		]
	uint64 LoadedEndingAddress;
		[Description (
		"A free form string describing the BIOS flash/load utility "
		"that is required to update the BIOSElement. Version and "
		"other information may be indicated in this property."),
		MaxLen (64), 
		MappingStrings {"MIF.DMTF|System BIOS|001.7"}
		]
	string LoadUtilityInformation;
		[Description (
		"Date that this BIOS was released."),
		MappingStrings {"MIF.DMTF|System BIOS|001.8"}
		]
	datetime ReleaseDate;
};

// ===================================================================
// BIOSFeatureBIOSElements
// ===================================================================
   [Association,
    Aggregation,
    Description (
       "A link between BIOSFeature and its aggregated BIOSElements.")
   ] 
class CIM_BIOSFeatureBIOSElements : CIM_SoftwareFeatureSoftwareElements
{
      [Override ("GroupComponent"), Aggregate,
       Description ("The BIOSFeature.")
      ]
   CIM_BIOSFeature REF GroupComponent;
      [Override ("PartComponent"),
       Description (
	  "The BIOSElement that implements the capabilities described "
	  "by BIOSFeature.")
      ]
   CIM_BIOSElement REF PartComponent;
};

// ===================================================================
// SystemBIOS
// ===================================================================
   [Association, Aggregation, 
    Description (
       "SystemBIOS associates a UnitaryComputerSystem's BIOS with the "
       "System itself.")
   ]
class CIM_SystemBIOS : CIM_SystemComponent
{
      [Override ("GroupComponent"), Max (1), Aggregate, 
       Description (
        "The UnitaryComputerSystem that boots from the BIOS.")
      ]
   CIM_UnitaryComputerSystem REF GroupComponent;
      [Override ("PartComponent"), 
       Description ("The System's BIOS.")
      ]
   CIM_BIOSElement REF PartComponent;
};

// ===================================================================
// Job
// ===================================================================
   [Abstract, 
    Description (
       "A Job is a LogicalElement representing a unit of work for a "
	 "System, such as a print job.  A Job is distinct from a "
	 "Process in that a Job can be scheduled.")
   ] 
class CIM_Job : CIM_LogicalElement
{
      [Description (
	  "A free form string representing the Job's status.")
      ]	
   string JobStatus;
      [Description ("Time that the Job was submitted.")]
   datetime TimeSubmitted;
      [Description ("Time that the Job was begun.")]
   datetime StartTime;
      [Description ("Length of time that the Job has been executing.")]
   datetime ElapsedTime;
      [Description (
	  "Time after which the Job is invalid or should be stopped.")
      ]
   datetime UntilTime;
      [Description (
	  "User to be notified upon Job completion or failure.")
      ]
   string Notify;
      [Description ("User that submitted the Job.")] 
   string Owner;
      [Description (
	  "Indicates the urgency or importance of execution of a Job.")
      ]
   uint32 Priority;
};

// ===================================================================
// JobDestination 
// ===================================================================
   [Description (
       "JobDestination is a LogicalElement representing where a Job "
       "is submitted for processing. It can refer to a queue that "
       "contains zero or more Jobs, such as a print queue containing "
       "print Jobs. JobDestinations are hosted on Systems, similar to "
       "the way that Services are hosted on Systems.")
   ] 
class CIM_JobDestination : CIM_LogicalElement
{
      [Propagated ("CIM_System.CreationClassName"),
       Key,
       Description ("The scoping System's CreationClassName."),
       MaxLen (256)
      ]
   string SystemCreationClassName;
      [Propagated ("CIM_System.Name"),
       Key,
       Description ("The scoping System's Name."),
       MaxLen (256)
      ]
   string SystemName;
      [Key,
       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."),
       MaxLen (256)
      ]
   string CreationClassName;
      [Override ("Name"),
       Key,
       Description (
	  "The inherited Name serves as key of a JobDestination "
	  "instance in a System."),
       MaxLen (256)
      ]
   string Name; 
};

// ===================================================================
// HostedJobDestination 
// ===================================================================
   [Association,
    Description (
       "An association between a JobDestination and a System on "
       "which it resides. The cardinality of this association is "
       "1-to-many.  A System may host many Job queues. Job"
       "Destinations are weak with respect to their hosting System. "
       "Heuristic: A JobDestination is hosted on the System where the "
       "LogicalDevices, SoftwareFeatures or Services that implement/"
       "provide the JobDestination are located.")
   ] 
class CIM_HostedJobDestination : CIM_Dependency
{
      [Override ("Antecedent"),
       Description ("The hosting System."),
       Min (1), Max (1)
      ] 
   CIM_System REF Antecedent;
      [Override ("Dependent"), 
       Description ("The JobDestination hosted on the System."),
       Weak
      ] 
   CIM_JobDestination REF Dependent;
};

// ===================================================================
// JobDestinationJobs 
// ===================================================================
   [Association,
    Description (
       "An association describing where a Job is submitted for "
       "processing, ie to which JobDestination.")
   ]
class CIM_JobDestinationJobs : CIM_Dependency
{
      [Override ("Antecedent"),
       Description ("The JobDestination, possibly a queue."),
       Max (1)        
      ] 
   CIM_JobDestination REF Antecedent;
      [Override ("Dependent"),
       Description ("The Job that is in the Job queue/Destination.")
      ] 
   CIM_Job REF Dependent;
};

// ==================================================================
//    DiagnosticTest
// ==================================================================
        [Description (
          "The CIM_DiagnosticTest class represents the ability to "
          "execute a test. Specific diagnostic tests may be defined by "
          "subclassing and/or instantiating this object. To provide "
          "more detail for a type of test (i.e, additional properties "
          "and methods), subclassing is appropriate. To indicate that a "
          "test exists and may be applied to a specific ManagedSystem"
          "Element, instantiation of the DiagnosticTest class may "
          "suffice.")
	  ] 
class CIM_DiagnosticTest : CIM_Service
{
        [Description (
	    "The descriptions for each Characteristic are below:\n "
	    "\n"
          "* \"Is Exclusive\" (value=2) is specified for the test "
          "module only if the diagnostic cannot run more than one test "
          "at a time, regardless of how many SystemElements are "
          "supported. Typically, this occurs when hardware or software "
          "constraints prevent the test from running as multiple, "
          "concurrent instances. If the diagnostic can be run against "
          "multiple SystemElements, but only once per Element, then set "
          "the IsExclusiveForMSE boolean property on the appropriate "
          "instances of DiagnosticTestForMSE. \n"
	    "\n"
	    "* If \"Is Interactive\" (value=3) is set, then the diagnostic "
          "displays a message either before, during or after testing. \n"
	    "\n"
	    "* Set \"Is Destructive\" (value=4) if the diagnostic will "
          "destroy data, or reconfigure the Element that is being "
          "tested. \n" 
	    "\n"
	    "* \"Is Risky\" (value=5) indicates that data loss may occur "
          "if the test is interrupted. Some tests make copies of data, "
          "perform the test, and restore the data returning the tested "
          "entity to its previous configuration. If the test is "
          "interrupted, then loss of data or reconfiguration of the "
          "tested ManagedSystemElement may occur. \n"
	    "\n"
	    "* If \"Is Package\" (value=6) is set, this test is actually "
          "a set of lower level diagnostics, that are 'packaged' "
          "together. \n"
          "\n"
          "\"Supports PercentOfTestCoverage\" (value=7) indicates that "
          "a request for reduced test coverage can be specified using "
          "the PercentOfTestCoverage property of Diagnostic Setting. \n"
          "\n"
          "Also, the values \"Unknown\" (0) and \"Other\" (1) may be "
          "specified. If \"Other\" is defined, additional detail may be "
          "found in the OtherCharacteristicDescription property of this "
          "class."), 
         Values{"Unknown", "Other", "Is Exclusive", "Is Interactive", 
             "Is Destructive", "Is Risky", "Is Package", 
             "Supports PercentOfTestCoverage"},
         ModelCorrespondence {
             "CIM_DiagnosticTest.OtherCharacteristicDescription"}
        ] 
	uint16 Characteristics[];
	  [Description (
          "Provides additional information for the Characteristic when "
          "its value is set to 1 (\"Other\")."), 
	   ModelCorrespondence {"CIM_DiagnotistTest.Characteristics"}
        ]
      string OtherCharacteristicDescription;
        [Description(
          "If this test is currently being performed, the InUse "
          "property is set to TRUE. To determine which ManagedSystem"
          "Element is being tested, query the DiagnosticResult objects "
          "associated with this test (query DiagnosticResultForTest), "
          "and for which the TestState equals 4 (\"In Progress\"). "
          "The DiagnosticResult object is associated with the System"
          "Element under test, using DiagnosticResultForMSE.")
        ]
	boolean IsInUse;
	  [Description(
	    "The \"Expensive\" qualifier can be applied to this class and "
          "its RunTest method. If so, the ResourcesUsed property "
          "describes the resources that are capitalized, based on a "
          "default setup for the test. Multiple resources can be "
          "specified since the property is an array."), 
	   ValueMap{"CPU", "Memory", "Hard Disk", "CDROM", "Floppy", 
             "PCI Bus", "USB Bus", "1394 Bus", "SCSI Bus", "IDE Bus", 
             "Network", "ISA Bus", "EISA Bus", "VESA Bus", "PCMCIA Bus", 
             "CardBus", "Access.bus", "NuBus", "AGP", "VME Bus", 
             "Sbus IEEE 1396-1993", "MCA Bus", "GIO Bus", "XIO Bus", 
             "HIO Bus", "PMC Bus", "SIO Bus"}
        ]
	uint16 ResourcesUsed[];
        [Description(
          "The RunTest method executes this test for the specified "
          "ManagedSystemElement (defined using the SystemElement input "
          "parameter). Results of the test are stored in a Diagnostic"
          "Result object, a reference to which is returned as the Result "
          "output parameter. How the test should execute, i.e. its "
          "settings, is defined in a DiagnosticSetting object (or by a "
          "subclass of DiagnosticSetting). A reference to a Setting "
          "object is specified using the Setting input parameter.  If a "
          "reference is not passed into the method, then a default "
          "DiagnosticSetting may be used. This default Setting is "
          "associated with the DiagnoticTest using the DefaultSetting "
          "relationship of the Core Model. \n"
          "The method's return codes are expected to adhere to the XML "
          "return codes as they are introduced. Currently, the standard "
          "return values are: \n"
	    "0 = OK (function succeeded, but the test itself may have "
          "failed \n"
	    "1 = Unspecified Error (function failed for unspecified "
          "reasons) \n"
	    "2 = Not Implemented (function is not implemented for this "
          "instance) \n"
	    "3 = Out Of Resources (component could not allocate required "
          "resources, e.g. memory, disk space, etc.) \n"
          "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 RunTest([IN] CIM_ManagedSystemElement ref SystemElement, 
          [IN] DiagnosticSetting ref Setting, 
          [OUT] CIM_DiagnosticResult ref Result);   
        [Description(
          "Execution of this method will delete all instances of the "
          "DiagnosticResultForMSE object, for this DiagnosticTest "
          "and the specified ManagedSystemElement (defined using the "
          "SystemElement input parameter). The DiagnosticResults "
          "referenced in the DiagnosticResultForMSE instances will be "
          "deleted.  Also the association DiagnosticResultForTest that "
          "referees to the DiagnosticResult object, and this test will "
          " be deleted.\n"
 
	  "  One output parameter is defined - ResultsNotCleared "
          "- which is a string array that lists the keys of the "
          "DiagnosticResults which could not be deleted. This information "
          "enables those Results to be revisited and either manually "
          "removed, or other corrective action taken. \n"
          "The method's return codes are expected to adhere to the XML "
          "return codes as they are introduced. Currently, the standard "
          "return values are: \n"
	    "0 = OK (function succeeded, but the test itself may have "
          "failed \n"
	    "1 = Unspecified Error (function failed for unspecified "
          "reasons) \n"
	    "2 = Not Implemented (function is not implemented for this "
          "instance) \n"
	    "3 = Out Of Resources (component could not allocate required "
          "resources, e.g. memory, disk space, etc.) \n"
          "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 ClearResults([IN] CIM_ManagedSystemElement ref SystemElement, 
          [OUT] String ResultsNotCleared[]);   
        [Description (
          "After invocation of this method and its completion, the "
          "specified test(s) will be discontinued for the indicated "
          "ManagedSystemElement (defined by the SystemElement input "
          "parameter). The test to discontinue is specified using the "
          "Result input parameter. If all instances of this test should "
          "be stopped for the SystemElement, then the Result reference "
          "should be NULL. Upon completion of the method, test status "
          "and other information (such as PercentComplete) will be "
          "stored in the DiagnosticResult instance defined by the Result "
          "input parameter. The output parameter, TestingStopped, is "
          "used as follows:\n"
          " Set to TRUE if testing was successfully stopped. \n"
          " Set to FALSE if the current test(s) can not be stopped. \n"
          "If set to FALSE, testing will stop when the diagnostic is "
          "able to do so safely. To determine if/when the testing is "
          "stopped, check the TestState property in the DiagnosticResult "
          "instance defined by the Result parameter. TestState will "
          "change from \"In Progress\" to \"Stopped\" (from 4 to 5). \n"
          "The method's return codes are expected to adhere to the XML "
          "return codes as they are introduced. Currently, the standard "
          "return values are: \n"
	    "0 = OK (function succeeded, but the test itself may have "
          "failed \n"
	    "1 = Unspecified Error (function failed for unspecified "
          "reasons) \n"
	    "2 = Not Implemented (function is not implemented for this "
          "instance) \n"
	    "3 = Out Of Resources (component could not allocate required "
          "resources, e.g. memory, disk space, etc.) \n"
          "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 DiscontinueTest([IN] CIM_ManagedSystemElement ref SystemElement, 
          [IN] CIM_DiagnosticResult ref Result, 
          [OUT] Boolean TestingStopped);   
};

// ==================================================================
//    DiagnosticSetting
// ==================================================================
        [Description(
	    "Specific diagnostic test parameters and execution "
          "instructions are defined by subclassing and/or instantiating "
          "the DiagnosticSetting object. To provide more detailed "
          "Settings for a type of test (i.e., additional properties), "
          "subclassing is appropriate. When only the generic Setting "
          "information is required, instantiation of the Diagnostic"
          "Setting class may suffice.")
        ] 
class CIM_DiagnosticSetting : CIM_Setting 
{
        [Key, MaxLen (256), Override ("SettingID"), 
         Description (
    	    "The identifier by which the DiagnosticSetting object is "
          "known and uniquely named. If there is a one to one mapping "
          "between the DiagnosticSetting and its DiagnosticTest (and "
          "there will always be only a one to one mapping), then the "
          "DiagnosticCreationClassName and DiagnosticName "
          "key pair can be used as the SettingID.") 
        ]
	string SettingID;
        [Description (
          "Sets the level of warning messages to be logged. If for "
          "example no warning information is required, the level "
          "would be set to \"No Warnings\" (value=0). Using \"Missing "
          "Resources\" (value=1) will cause warnings to be generated "
          "when required resources or hardware are not found. Setting "
          "the value to 2, \"Testing Impacts\", results in both "
          "missing resources and 'test impact' warnings (for example, "
          "multiple retries required) to be reported."), 
	   Values{"No Warnings", "Missing Resources", 
            "Testing Impacts", "All Warnings"},
	   Write
        ] 
    uint16 TestWarningLevel;
        [Description (
	    "When this flag is true, the diagnostic test will report "
          "'soft errors'. In this context, a soft error is a message "
          "from the diagnostic reporting a known defect in the "
          "hardware or driver configuration, or execution "
          "environment.  Examples are: \"Not enough memory\", "
          "\"Driver IOCTL not implemented\", \"Video RAM compare "
          "failed during polygon fill test (A known defect in the "
          "video chipset)\", etc."),
	   Write
        ] 
    boolean ReportSoftErrors;
        [Description (
	    "When this flag is true, the diagnostic test will report "
          "'status messages'. In this context, a status message "
          "indicates that the diagnostic code is at a checkpoint. "
	    "Examples are: \"Completion of phase 1\", \"Complex "
          "pattern\", etc."),
	   Write
	  ] 
    boolean ReportStatusMessages;
        [Description (
	    "When this flag is true, the test will halt after finding "
          "the first error."),
	   Write
	  ] 
    boolean HaltOnError;
        [Description (
          "When this flag is true, the test software should attempt "
          "to run in an accelerated fashion either by reducing the "
          "coverage or number of tests performed."), 
	   Write
        ] 
    boolean QuickMode;
        [Units ("Percent"), MinValue (0), MaxValue (100), 
         Description(
	    "Requests the diagnostic software to reduce test coverage "
          "to the specified percentage.  For example, a hard drive "
          "scan test could be asked to run at 50%. The most "
          "effective way to accomplish this is for the test software "
          "to scan every other track, as opposed to only scanning the "
          "first half of a drive. It is assumed that the effectiveness "
          "of the test is impacted proportional to the percentage of "
          "testing requested. Permissible values for this property "
          "range from 0 to 100. \n"
          "This property may not be applicable to all tests.  If it "
          "can be set for a test, the value 7 (\"Supports PercentOf"
          "TestCoverage\") should be entered into the DiagnosticTest's "
          "Characteristics array."), 
         ModelCorrespondence {"CIM_DiagnosticTest.Characteristics"}, 
	   Write
        ] 
    uint8 PercentOfTestCoverage;
 };

// ==================================================================
//    DiagnosticResult
// ==================================================================
        [Description(
          "When a DiagnosticTest Service is running, test results "
          "are reported using a DiagnosticResult object, or one of its "
          "subclasses. A DiagnosticTest may be running because its "
          "Service is Started or due to an invocation of the RunTest "
          "method. DiagnosticResults are related to their Test via an "
          "instance of the DiagnosticResultsForMSE association.")
        ] 
class CIM_DiagnosticResult
{
        [Propagated("CIM_DiagnosticTest.CreationClassName"), 
         Key, MaxLen (256),
         Description ("The scoping Test's CreationClassName.") 
        ]
	string DiagnosticCreationClassName;
        [Propagated("CIM_DiagnosticTest.Name"),
         Key, MaxLen (256),
         Description ("The scoping Test's Name.") 
        ]
	string DiagnosticName;
        [Key, MaxLen (1024), 
         Description (
          "The Unique identifier for an instance of Diagnostic"
          "Results.")
        ] 
    string ExecutionID ; 
        [Description (
          "The date and time the result was last updated.")
        ] 
    datetime TimeStamp;
        [Description (
          "If this property is TRUE, then this DiagnosticResult "
          "summarizes the results from the execution of a packaged "
          "set of DiagnosticTests. The Tests in the package can be "
          "identified by following the DiagnosticResultForTest "
          "association to the test and then using the DiagnosticTest"
          "InPackage aggregation. The individual Results can be "
          "broken out by instantiating DiagnosticResults for the "
          "individual lower level tests and aggregating into the "
          "'summary' Result using the DiagnosticResultInPackage "
          "association.") 
        ]
    boolean IsPackage;
        [Description (
          "The date and time  when this test started.")
        ] 
    datetime TestStartTime;
        [Description (
          "The date and time when this test completed.")
        ] 
    datetime TestCompletionTime;
        [Description (
          "Describes how the test is progressing. For example, if "
          "the test was discontinued, the TestState will be "
          "\"Stopped\" (value=5), or if testing is currently "
          "executing, TestState will be \"In Progress\" (4)."),  
	   Values{"Unknown", "Other", "Passed", "Failed", 
             "In Progress", "Stopped"},
         ModelCorrespondence {
             "CIM_DiagnosticResult.OtherStateDescription"}
        ] 
     uint16 TestState;
        [Description (
          "When \"Other\" (value=1) is entered in the TestState "
          "property, OtherStateDescription can be used to describe "
          "the test's state."),
         ModelCorrespondence {"CIM_DiagnosticResult.TestState"}
        ]
     string OtherStateDescription;
        [Units ("Seconds"), 
         Description (
          "Estimated number of seconds to perform the Diagnostic"
          "Test indicated by the DiagnosticCreationClassName and "
          "DiagnosticName properties.  After the test has completed, "
          "the actual elapsed time can be determined by subtracting "
          "the TestStartTime from the TestCompletionTime. A similar "
          "property is defined in the association, DiagnosticTest"
          "ForMSE. The difference between the two properties is "
          "that the value stored in the association is a generic "
          "test execution time for the Element and the Test. But, "
          "the value here (in DiagnosticResult) is the estimated "
          "time that this instance of testing would run."), 
         ModelCorrespondence {
             "CIM_DiagnosticTestForMSE.EstimatedTimeOfPerforming"}
        ]
    uint32 EstimatedTimeOfPerforming;
        [Description(
          "TestResults stores one or more textual results from the "
          "execution of the DiagnosticTest(s) referenced by the "
          "DiagnosticCreationClassName and DiagnosticName properties. "
          "One entry is considered a cell location in the array. Each "
          "entry is time stamped and contains the following "
          "information, in the following format: \n"
          " yyymmddhhttssoutc|DiagnosticName|Textual message \n"
          "Where: \n"
          "  yyy = year, e.g. 2000 \n"
          "  mm = month (01 - 12) \n"
          "  dd = day (01 - 31) \n" 
          "  hh = hour (00 - 24) \n"
          "  tt = minute (00-59) \n"
          "  ss = second (00-59) \n"
          "  o = \"+\" or \"-\" indicating the sign of the UTC "
          "correction field \n"
          "  utc = offset from UTC (Universal Coordinated Time) "
          "in minutes \n"
          "  DiagnosticName = string reference to the DiagnosticTest "
          "object which was executed\n"
          "  Textual message = free form string that is the 'test "
          "result'."), 
         ArrayType ("Ordered")
        ] 
    string TestResults[];
        [Units ("Percent"), MinValue (0), MaxValue (100), 
         Description (
         "The percentage of the test that has executed thus far, if the "
         "TestState property is set to \"In Progress\" or the percentage "
         "of the complete test that was executed if the TestState property "
         "is set to any of the completed states (\"Passed\", \"Failed\" or "
         "\"Stopped\"). Final results may be based on less than 100% coverage "
         "due to the parameters defined in DiagnosticSetting (such as "
         "QuickMode, PercentOfTestCoverage or HaltOnError)." )
        ]
    uint8 PercentComplete;

};

// ==================================================================
//    DiagnosticResultForMSE
// ==================================================================
        [Association, Description (
          "This is an association class relating diagnostic test "
          "results to the ManagedSystemElement that is/was tested.")
        ]
class CIM_DiagnosticResultForMSE
{
        [Key, Description (
          "The diagnostic result.")
        ]
   CIM_DiagnosticResult REF Result;
        [Key, Description (
          "The ManagedSystemElement to which the diagnostic result "
          "applies.")
        ]
   CIM_ManagedSystemElement REF SystemElement;
};

// ==================================================================
//    DiagnosticResultForTest
// ==================================================================
        [Association, Description (
          "This is an association class to relate the results of a test "
          "to the test itself.")
	  ] 
class CIM_DiagnosticResultForTest 
{
        [Weak, Min (1), Max (1), Key, 
         Description ("The result object.")
	  ]
   CIM_DiagnosticResult REF DiagnosticResult;
	  [Min(1), Max(1), Key, 
         Description ("The test that generated the result object.")
	  ]
   CIM_DiagnosticTest REF DiagnosticTest;
};

// ==================================================================
//    DiagnosticTestForMSE
// ==================================================================
        [Association, Description(
	    "This is an association class that relates a DiagnosticTest "
          "to a ManagedSystemElement.  Consumers wishing to 'diagnose' "
          "a particular Element could query this association, for the "
          "Element, to determine what tests are available.")
	  ] 
class CIM_DiagnosticTestForMSE : CIM_ProvidesServiceToElement
{
	  [Override("Antecedent"), Description (
          "The test that may be run against a ManagedSystemElement.")
        ]
   CIM_DiagnosticTest REF Antecedent;
	  [Override("Dependent"), Description (
          "The ManagedSystemElement that can be tested.")
        ]
   CIM_ManagedSystemElement REF Dependent;
        [Units ("Seconds"), 
         Description (
	    "Estimated number of seconds to perform the referenced "
          "DiagnosticTest against the ManagedSystemElement. Since "
          "execution times could vary by Element, this property is "
          "located in the association between the two entities. It is "
          "also captured in DiagnosticResult, in the Estimated"
          "TimeOfPerforming property."), 
         ModelCorrespondence {
             "CIM_DiagnosticResult.EstimatedTimeOfPerforming"}
        ]
    uint32 EstimatedTimeOfPerforming;
	  [Description (
          "If the DiagnosticTest referenced in this object can be run "
          "concurrently against multiple SystemElements, but only "
          "run one at a time for the referenced ManagedSystemElement, "
          "then this boolean is set to TRUE. Alternately, if the test "
          "can NOT be run concurrently irregardless of the System"
          "Elements being tested, then the more general \"Is Exclusive\" "
          "enumerated value (2) should be set in DiagnosticTest."
          "Characteristics.")
        ]
    boolean IsExclusiveForMSE;
};

// ==================================================================
//    DiagnosticTestInPackage
// ==================================================================
        [Association, Aggregation, 
         Description (
    	    "This is an association class that identifies a Diagnostic"
          "Test as made up of lower level Tests. In this case, the "
          "Test identified as the GroupComponent reference (i.e, "
          "the higher level test) would have the \"Is Package\" "
          "enumerated value specified in DiagnosticTest."
          "Characteristics.")
	] 
class CIM_DiagnosticTestInPackage : CIM_Component
{
	[Override("GroupComponent"), 
       Description (
        "The DiagnosticTest object that acts as the container for all "
        "the tests of the package.")
      ]
   CIM_DiagnosticTest REF GroupComponent;
	[Override("PartComponent"), 
       Description (
        "The DiagnosticTest object that is one of the elements of "
        "the package.")
      ]
   CIM_DiagnosticTest REF PartComponent;  
};
     
// ==================================================================
//    DiagnosticResultInPackage
// ==================================================================
        [Association, Aggregation, 
         Description(
	    "This is an association class that identifies a Diagnostic"
          "Result as made up of lower level Results. In this case, the "
          "Result identified as the PackageResult reference (i.e., "
          "the higher level result) would have its IsPackage property "
          "set to TRUE.")
	  ] 
class CIM_DiagnosticResultInPackage 
{
	[Key, Description (
       "The DiagnosticResult object that acts as the container for all "
       "the results of the package.")
      ]
   CIM_DiagnosticResult REF PackageResult;
	[Key, Description (
        "The DiagnosticResult object that is one of the elements of "
        "the package.")
      ]
   CIM_DiagnosticResult REF Result; 
};

     
// ==================================================================
//    DiagnosticTestSoftware
// ==================================================================
        [Association, Description(
	    "This is an association class relating DiagnosticTest to "
          "the SoftwareElements that provide this test. SoftwareElement "
          "describes vendor/version information and other deployment "
          "data.")
	  ] 
class CIM_DiagnosticTestSoftware : CIM_Dependency
{
	  [Override ("Antecedent"), Description (
	     "Vendor/version and other information about the software "
           "that runs as the DiagnosticTest.")
	  ]
   CIM_SoftwareElement REF Antecedent;
	  [Override ("Dependent"), Description (
          "The DiagnosticTest whose software is described.")
        ] 
   CIM_DiagnosticTest REF Dependent;
};
  

// ==================================================================
//    DiagnosticSettingForTest
// ==================================================================
        [Association, Description (
	    "This is an association class to relate test settings with "
	    "diagnostic tests.")
	  ] 
class CIM_DiagnosticSettingForTest : CIM_ElementSetting
{
	[Override("Element"), Description (
        "The Test that can use the Setting object.")
      ]
   CIM_DiagnosticTest REF Element;
	[Override("Setting"), Description (
        "The Setting that can be applied to the execution of the "
        "DiagnosticTest.")
      ]
   CIM_DiagnosticSetting REF Setting;
};

  

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


