// ==================================================================
// Title:  	  Core MOF Specification 2.3
// Filename:  CIM_Core23.MOF
// Date:  04/14/1998 - Version 2.0 
//	    06/16/1998 - V2.0 Errata
//		- CR224, CIM_ missed in 3 class names
//                CIM_ProductPhysicalElements, CIM_FRUPhysicalElements
//                and CIM_FRUIncludesProduct
//		- CR231, Format for specifying Propagated keys uses
//                period, not colon
//	    09/29/1998 - Version 2.1 
//		- CR238, Add CompatibleProduct association
//		- CR239, Add ProductProductDependency association
//		- CR240, Add statistics-related objects
//			CIM_StatisticalInformation, CIM_Statistics and
//			CIM_RelatedStatistics
//		- CR241, Remove "general" from the description of the
//			compute capabilities of ComputerSystem
//		- CR242a, Add to the enumeration for MSE.Status
//		- CR249, Add LastErrorCode, ErrorDescription and
//			ErrorCleared properties to LogicalDevice
//		- CR250, Add CreationClassName (key) to PhysicalElement
//		- CR252, Add OtherIdentifyingInfo and PoweredOn properties
//			to PhysicalElement
//		- CR270, Correct the descriptions for Product and FRU
//		- CR272, Remove repetition of the Values array from the
//			descriptions of several properties
//		- CR276b, Add to the enumeration for LogicalDevice.
//			Availability 
//		- CR282, Add PartNumber property to PhysicalElement
//	    06/08/1999 - Version 2.2
//		- CR291a, Write qualifier "False" by default
//		- CR295a, Clarify Descriptions for CIM_Product and its
//			property, IdentifyingNumber 
//		- CR300a, Enhance Description for CIM_SettingContext
//		- CR304, Create the NullValue qualifier
//		- CR305, Add DisableOverride flavor to In, Out, Override
//		- CR306, Add DisableOverride flavor to Aggregation 
//			(Already present in V2.1, Spec change only)
//		- CR307b, Allow ArrayType, MaxLen, Units, ValueMap, Values,
//			Syntax and SyntaxType qualifiers to pertain to methods
//			and method parameters 
//		- CR308a, Add LogicalIdentity association
//		- CR309, Remove Min(1) from ManagedSystemElement 
//                 reference of ElementSetting
//		- CR315, Create ProvidesServiceToElement association
//		- CR317, Create DefaultSetting association
//		- CR320, Add UnknownValues and UnsupportedValues qualifiers
//		- CR321, Create ConfigurationComponent association
//		- CR322b and 323a, Add 4 methods to 'apply' CIM_Settings
//		- CR324a, Add CollectionOfMSE object and its associations
//		- CR352b, New statuses in ManagedSystemElement.Status
//                 (NonRecover and Stressed added)
//		- CR353b, Add EnableDevice method to LogicalDevice
//		- CR355a, Use Values-ValueMap qualifiers for the PowerState  
//			 parameter of LogicaDevice.SetPowerState / Update
//			 the method descriptions indicating that Values-
//			 ValueMap qualifiers can be defined for return codes
//          - CR356a, Put keys on the references of Dependency,
//			 Component, and all of the non-subclassed Setting, 
//                 Configuration, Product and Collection associations 
//		- CR359, Clarify PhysicalElement.Manufacturer and 
//			 Product.Vendor
//		- CR361a, Add Terminal and DisplayName qualifiers
//		- CR362a, Add 3 properties to ComputerSystem (Dedicated,
//			 OtherIdentifyingInfo and IdentifyingDescriptions) /
//			 Update the Description for System.Roles
// 		- CR376, Add OtherIdentifyingInfo and 
//		       IdentifyingDescriptions properties to LogicalDevice
//		- CR387, Add PowerOnHours and TotalPowerOnHours properties
//			 to LogicalDevice / Update the Availability enum
//		- CR389, Add MinValue and MaxValue qualifiers
//		- CR390a, Create subclasses of StatisticalInformation
//			 to formalize naming
//		- CR391b, 400a and 401b, Add Counter, Gauge, BitMap, 
//                 BitValue and Static qualifiers / Update MinValue 
//                 and MaxValue to apply to methods and parameters
//		- CR396d, Add NonlocalType and SourceType qualifiers
//		- CR404a, Add ServiceComponent association
//		- CR405, Add Counter qualifier to PowerOnHours and
//                 and TotalPowerOnHours properties of LogicalDevice
//		- CR411, Add Provider qualifier
//		- CR413, Fix propagation of keys from 390a
//        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, New properties and enums from Master.MIF 
//				and new ModelCorrespondences
//		- CR444, Add the RestartService property to the 
//				CIM_ServiceServiceDependency association in the 
//				core mof to support diagnostics. 
//		- CR445e Modify the LogicalDevice for Fault Tolerance: 
//				Update the Availability property, add an AdditionalAvailability 
//				property, change the description for the StatusInfo property
//				add new methods, and add a MaxQuiesceTime property
//		- CR446c add Octetstring Qualifier 
//		- CR448b Add ManagedElement, Collection  and MemberOfCollection Classes, 
//				update ManagedSystemElement and Dependency classes accordingly
//		- CR456 Add "Management" to the end of the Values array for 
//				CIM_ComputerSystem.Dedicated
//		- CR458c Add a new association, CIM_Synchronized  
//		- CR461 Subclass from CIM_ManagedElement, CIM_Collection and 
//			CIM_MemberOfCollection.  
//			Remove Description & Caption from the above classes, where exist.
//		- CR462 Update the Description for ManagedElement, Add qualifier in 
//			MemberOfCollection
// ==================================================================

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

// ==================================================================
// Qualifiers
// ==================================================================

Qualifier Abstract : boolean = false, Scope(class, association, 
	indication), Flavor(DisableOverride, Restricted);
Qualifier Aggregate: boolean = false, Scope (reference),
	Flavor(DisableOverride);
Qualifier Aggregation : boolean = false, Scope(association),
	Flavor(DisableOverride);
Qualifier Alias : string = null, Scope(property, reference, 
	method), Flavor(Translatable);
Qualifier ArrayType : string = "Bag", Scope(property, parameter);
Qualifier Association : boolean = false, Scope(class, association), 
      Flavor(DisableOverride);
Qualifier BitMap : string[], Scope(property, method, parameter);
Qualifier BitValues : string[], Scope(property, method,
	parameter), Flavor(Translatable);
Qualifier Counter : boolean = false, Scope(property, method, 
	parameter);
Qualifier Delete : boolean = false, Scope(association, reference);
Qualifier Description : string = null, Scope(any), 
	Flavor(Translatable);
Qualifier DisplayName : string = null, Scope(any),
	Flavor(Translatable);
Qualifier Expensive : boolean = false, 
	Scope(property, reference, method, class, association);
Qualifier Gauge : boolean = false, Scope(property, method, 
	parameter);
Qualifier Ifdeleted : boolean = false, Scope(association, 
	reference);
Qualifier In : boolean = true, Scope(parameter),
	Flavor(DisableOverride);
Qualifier Indication : boolean = false, Scope(class, indication), 
	Flavor(DisableOverride);
Qualifier Invisible : boolean = false,
	Scope(reference, association, class, property, method);
Qualifier Key : boolean = false, Scope(property, reference), 
	Flavor(DisableOverride);
Qualifier Large : boolean = false, Scope(property, class);
Qualifier MappingStrings : string[],
	Scope(class, property, association, indication, reference);
Qualifier Max : uint32 = null, Scope(reference);
Qualifier MaxLen : uint32 = null, Scope(property, method, 
	parameter);
Qualifier MaxValue : sint64 = null, Scope(property, method,
	parameter);
Qualifier Min : uint32 = 0, Scope(reference);
Qualifier MinValue : sint64 = null, Scope(property, method,
	parameter);
Qualifier ModelCorrespondence : string[], Scope(property);
Qualifier Nonlocal : string = null, Scope(reference);
Qualifier NonlocalType : string = null, Scope(reference);
Qualifier NullValue : string = null, Scope (property),
      Flavor(DisableOverride);
Qualifier Octetstring : boolean = false, Scope(property, parameter);
Qualifier Out : boolean = false, Scope(parameter),
	Flavor(DisableOverride);
Qualifier Override : string = null, Scope(property, method, 
	reference), Flavor(DisableOverride);
Qualifier Propagated : string = null, Scope(property),
	Flavor(DisableOverride);
Qualifier Provider : string = null, Scope(any);
Qualifier Read : boolean = true, Scope(property);
Qualifier Required : boolean = false, Scope(property);
Qualifier Revision : string = null, Scope(schema, class, 
	association, indication ), Flavor(Translatable);
Qualifier Schema : string = null, Scope (property, method), 
	Flavor(DisableOverride, Translatable);
Qualifier Source : string = null, Scope(class, association, 
	indication);
Qualifier SourceType : string = null, Scope(class, association, 
      indication, reference);
Qualifier Static : boolean = false, Scope(method, property),
	Flavor(DisableOverride);
Qualifier Syntax : string = null, Scope(property, reference,
	method, parameter);
Qualifier SyntaxType : string = null, Scope(property, reference,
	method, parameter);
Qualifier Terminal : boolean = FALSE, Scope(class);
Qualifier TriggerType : string = null,
	Scope(class, property, reference, method, association, 
	indication);
Qualifier Units : string = null, Scope(property, method,  
	parameter), Flavor(Translatable);
Qualifier UnknownValues : string[], Scope(property),
	Flavor(DisableOverride);
Qualifier UnsupportedValues : string[], Scope(property),
	Flavor(DisableOverride);
Qualifier ValueMap : string[], Scope(property, method, parameter);
Qualifier Values : string[], Scope(property, method, parameter), 
	Flavor(Translatable);
Qualifier Version : string = "V2.2", Scope(schema, class, 
	association, indication), Flavor(Translatable);
Qualifier Weak : boolean = false, Scope(reference), 
      Flavor(DisableOverride, ToSubclass);
Qualifier Write : boolean = false, Scope(property);

// ==================================================================
// ManagedElement
// ================================================================== 
   [Abstract, Description (
   "ManagedElement is an abstract class that provides a common "  
	"superclass (or top of the inheritance tree) for the "
	"non-association classes in the CIM Schema.")]
   class CIM_ManagedElement   
   {  
     [MaxLen (64), Description (  
      "The Caption property is a short textual description (one-"    
      "line string) of the object.") ]   
     string Caption;  
     [Description (  
      "The Description property provides a textual description of "
      "the object.") ]   
     string Description;    
   };
     
// ================================================================== 
//    ManagedSystemElement
// ==================================================================
        [Abstract, Description (
         "CIM_ManagedSystemElement is the base class for the System "
         "Element hierarchy. Membership Criteria: Any distinguishable "
         "component of a System is a candidate for inclusion in this "
         "class. Examples: software components, such as files; and "
         "devices, such as disk drives and controllers, and physical "
  	   "components such as chips and cards.") ] 
class CIM_ManagedSystemElement : CIM_ManagedElement
{
        [Description (
         "A datetime value indicating when the object was installed. "
         "A lack of a value does not indicate that the object is not "
         "installed."), 
         MappingStrings {"MIF.DMTF|ComponentID|001.5"} ] 
    datetime InstallDate;
        [MaxLen (256), Description (
         "The Name property defines the label by which the object is "
	   "known. When subclassed, the Name property can be overridden "
         "to be a Key property.") ] 
    string Name;
	  [MaxLen (10), Description ( 
         "A string indicating the current status of the object. "
         "Various operational and non-operational statuses are "
         "defined. Operational statuses are \"OK\", \"Degraded\", "
         "\"Stressed\" and \"Pred Fail\". \"Stressed\" indicates that "
         "the Element is functioning, but needs attention. Examples "
         "of \"Stressed\" states are overload, overheated, etc. The "
         "condition \"Pred Fail\" (failure predicted) indicates that "
         "an Element is functioning properly but predicting a failure "
         "in the near future. An example is a SMART-enabled hard "
         "drive. Non-operational statuses can also be specified. These "
         "are \"Error\", \"NonRecover\", \"Starting\", \"Stopping\" "
         "and \"Service\". \"NonRecover\" indicates that a non-"
         "recoverable error has occurred. \"Service\" describes an "
         "Element being configured, maintained or cleaned, or "
         "otherwise administered. This status could apply during "
         "mirror-resilvering of a disk, reload of a user permissions "
         "list, or other administrative task. Not all such work is "
         "on-line, yet the Element is neither \"OK\" nor in one of "
         "the other states."),
         ValueMap {"OK", "Error", "Degraded", "Unknown", "Pred Fail",
             "Starting", "Stopping", "Service", "Stressed", 
             "NonRecover"} ] 
    string Status;
};

// ==================================================================
// Collection 
// ================================================================== 
  [Abstract, Description (   
   "Collection is an abstract class that provides a common"   
   "superclass for data elements that represent collections of "
   "ManagedElements and its subclasses.")]
  class CIM_Collection : CIM_ManagedElement    
  {   
  };

// ===================================================================
//    CollectionOfMSEs
// ===================================================================
        [Abstract, Description (
         "The CollectionOfMSEs object allows the grouping of Managed"
         "SystemElements for the purposes of associating Settings and "
         "Configurations. It is abstract to require further definition "
         "and semantic refinement in subclasses. The CollectionOfMSEs "
         "object does not carry any state or status information, but "
         "only represents a grouping or 'bag' of Elements. For this "
         "reason, it is incorrect to subclass groups that have state/"
         "status from CollectionOfMSEs - an example is CIM_Redundancy"
         "Group (which is correctly subclassed from LogicalElement).\n"
         "Collections typically aggregate 'like' objects, and represent "
         "an optimization. Without Collections, one is forced to define "
         "individual ElementSetting and ElementConfiguration "
         "associations, to tie Settings and Configuration objects to "
         "individual ManagedSystemElements. There may be much "
         "duplication in assigning the same Setting to multiple objects. "
         "In addition, using the Collection object allows the "
         "determination that the Setting and Configuration associations "
         "are indeed the same for the Collection's members. This "
         "information would otherwise be obtained by defining the "
         "Collection in a proprietary manner, and then querying "
         "the ElementSetting and ElementConfiguration associations to "
         "determine if the Collection set is completely covered.") ]
class CIM_CollectionOfMSEs : CIM_Collection
{
        [MaxLen (256), Description (
         "The identification of the Collection object. When subclassed, "
         "the CollectionID property can be overridden to be a Key "
         "property.") ]
   string CollectionID;
        [MaxLen (64), Description (
         "A short textual description (one-line string) of the "
         "CollectionOfMSEs object.") ]
   string Caption;
        [Description (
         "A textual description of the CollectionOfMSEs object.") ]
   string Description;
};

// ==================================================================
//    CollectedCollections
// ==================================================================
        [Association, Aggregation, Description (
         "CIM_CollectedCollections is an aggregation association "
         "representing that a CollectionOfMSEs may itself be contained "
         "in a CollectionOfMSEs.") ]
class CIM_CollectedCollections
{
        [Aggregate, Key, Description (
         "The 'higher level' or parent element in the aggregation.") ]
   CIM_CollectionOfMSEs REF Collection;
        [Key, Description ("The 'collected' Collection.") ]
   CIM_CollectionOfMSEs REF CollectionInCollection;
};
     
// ================================================================= 
//    PhysicalElement
// ==================================================================
        [Abstract, Description (
         "Subclasses of CIM_PhysicalElement define any component of a " 
         "System that has a distinct physical identity. Instances of "
         "this class can be defined in terms of labels that can be "
         "physically attached to the object. All Processes, Files, "
	   "and LogicalDevices are considered not to be Physical"
         "Elements. For example, it is not possible to attach a "
         "label to a modem. It is only possible to attach a label to "
         "the card that implements the modem. The same card could "
         "also implement a LAN  adapter. These are tangible Managed "
         "System Elements (usually actual hardware items) that have a "
         "physical manifestation of some sort. A Managed System "
         "Element is not necessarily a discrete component. For "
         "example, it is possible for a single Card (which is a type "
         "of Physical Element) to host more than one Logical Device. "
         "The card would be represented by a single Physical Element "
 	   "associated with multiple Logical Devices.") ] 
class CIM_PhysicalElement:CIM_ManagedSystemElement
{
        [Key, MaxLen (256), Description (
         "CreationClassName indicates the name of the class or the "
         "subclass used in the creation of an instance. When used "
         "with the other key properties of this class, this property "
         "allows all instances of this class and its subclasses to "
         "be uniquely identified.") ]
    string CreationClassName;
        [MaxLen (256), Description (
         "The name of the organization responsible for producing the "
         "PhysicalElement. This may be the entity from whom the Element "
         "is purchased, but this is not necessarily true. The latter "
         "information is contained in the Vendor property of "
         "CIM_Product.") ] 
    string Manufacturer;
        [MaxLen (64), Description (
         "The name by which the PhysicalElement is generally known.") ] 
    string Model;
        [MaxLen (64), Description (
         "The stock keeping unit number for this PhysicalElement.") ] 
    string SKU;
        [MaxLen (64), Description (
         "A manufacturer-allocated number used to identify the Physical"
         "Element.") ] 
    string SerialNumber;
        [Key, MaxLen (256), Description (
         "An arbitrary string that uniquely identifies the Physical"
	   "Element and serves as the Element's key.  The Tag property "
	   "can contain information such as asset tag or serial number "
	   "data. The key for PhysicalElement is placed very high in the "
	   "object hierarchy in order to independently identify the "
	   "hardware/entity, regardless of physical placement in or on "
	   "Cabinets, Adapters, etc.  For example, a hotswappable or "
	   "removeable component may be taken from its containing "
	   "(scoping) Package and be temporarily unused.  The object "
         "still continues to exist - and may even be inserted into a "
	   "different scoping container.  Therefore, the key for Physical"
	   "Element is an arbitrary string and is defined independently "
	   "of any placement or location-oriented hierarchy.") ]
    string Tag;
        [MaxLen (64), Description (
	   "A string indicating the version of the PhysicalElement.") ] 
    string Version;
	  [MaxLen (256), Description (
	   "The part number assigned by the organization responsible for "
	   "producing or manufacturing the PhysicalElement.") ]
    string PartNumber;
	  [Description (
	   "OtherIdentifyingInfo captures additional data, beyond asset "
	   "tag information, that could be used to identify a Physical"
	   "Element. One example is bar code data associated with an "
	   "Element that also has an asset tag. Note that if only bar "
	   "code data is available and is unique/able to be used as an "
	   "Element key, this property would be NULL and the bar code "
	   "data used as the class key, in the Tag property.") ]
    string OtherIdentifyingInfo;
	  [Description (
	   "Boolean indicating that the PhysicalElement is powered on "
	   "(TRUE), or is currently off (FALSE).") ]
    boolean PoweredOn;
	  [Description (
	  "Date that this PhysicalElement was manufactured.") ]
	datetime ManufactureDate;
};
     
// ==================================================================
//    LogicalElement
// ==================================================================
        [Abstract, Description (
         "CIM_LogicalElement is a base class for all the components of "
         "a System that represent abstract system components, such "
         "as Files, Processes, or system capabilities in the form "
         "of Logical Devices.") ] 
class CIM_LogicalElement:CIM_ManagedSystemElement
{
};
     
// ==================================================================
//    LogicalIdentity
// ==================================================================
	  [Association, Abstract, Description (
	   "CIM_LogicalIdentity is an abstract and generic association, "
	   "indicating that two LogicalElements represent different "
	   "aspects of the same underlying entity. This relationship "
	   "conveys what could be defined with multiple inheritance. It "
	   "is restricted to the 'logical' aspects of a ManagedSystem"
	   "Element. In most scenarios, the Identity relationship is "
	   "determined by the equivalence of Keys or some other "
	   "identifying properties of the related Elements. The "
	   "association should only be used in well understood scenarios. "
	   "This is why the association is abstract - allowing more "
	   "concrete definition and clarification in subclasses. One of "
	   "the scenarios where this relationship is reasonable is to "
	   "represent that a Device is both a 'bus' entity and a "
	   "'functional' entity. For example, a Device could be both a "
	   "USB (bus) and a Keyboard (functional) entity.") ]
class CIM_LogicalIdentity
{
        [Key, Description (
         "SystemElement represents one aspect of the Logical"
	   "Element.") ]
   CIM_LogicalElement ref SystemElement;
        [Key, Description (
         "SameElement represents an alternate aspect of the "
         "System entity.") ]
   CIM_LogicalElement ref SameElement;
};

// ===================================================================
//    Configuration
// ===================================================================
        [Description (
         "The Configuration object allows the grouping of sets of "
         "parameters (defined in Setting objects) and dependencies for "
         "one or more ManagedSystemElements. The Configuration object "
         "represents a certain behavior, or a desired functional state "
         "for the ManagedSystemElements. The desired functional state "
         "is typically driven by external requirements such as time or "
         "location. For example, to connect to a Mail System from "
         "'home', a dependency on a modem exists, but a dependency on "
         "a network adapter exists at 'work'. Settings for the "
	   "pertinent LogicalDevices (in this example, POTSModem and "
	   "NetworkAdapter) can be defined and aggregated by the "
	   "Configuration. Therefore, two 'Connect to Mail' "
	   "Configurations may be defined grouping the relevant "
	   "dependencies and Setting objects.") ]
class CIM_Configuration : CIM_ManagedElement
{
        [Key, MaxLen (256), Description (
         "The label by which the Configuration object is known.") ]
   string Name;
        
};

// ===================================================================
//    ConfigurationComponent
// ===================================================================
        [Association, Aggregation, Description (
	   "ConfigurationComponent aggregates 'lower-level' "
         "Configuration objects into a 'high-level' Configuration. "
         "This enables the assembly of complex Configurations by "
         "grouping together simpler ones. For example, a logon policy "
         "for the United States could consist of two Configuration "
         "groups, one for the east coast and one for the west coast. "
         "Each of these could in turn consist of multiple "
         "Configurations to handle different aspects of the logon "
         "process.") ]
class CIM_ConfigurationComponent
{
        [Aggregate, Key, Description (
         "The Configuration that aggregates additional "
         "Configurations." ) ]
   CIM_Configuration REF ConfigGroup;
	  [Key, Description (
         "A Configuration that is part of a 'higher-level' "
         "Configuration.") ]
   CIM_Configuration REF ConfigComponent;
};

// ===================================================================
//    ElementConfiguration
// ===================================================================
        [Association, Description (
         "This association relates a Configuration object to one or "
         "more ManagedSystemElements. The Configuration object "
         "represents a certain behavior, or a desired functional state "
         "for the associated ManagedSystemElements.") ]
class CIM_ElementConfiguration
{
        [Key, Description ("The ManagedSystemElement.")]
   CIM_ManagedSystemElement REF Element;
        [Key, Description (
         "The Configuration object that groups the Settings and "
         "dependencies associated with the ManagedSystemElement.") ] 
   CIM_Configuration REF Configuration;
};

// ===================================================================
//    CollectionConfiguration
// ===================================================================
        [Association, Description (
         "This association relates a Configuration object to one or "
         "more CollectionOfMSEs objects. The Configuration object "
         "represents a certain behavior, or a desired functional state "
         "for the associated Collection.") ]
class CIM_CollectionConfiguration
{
        [Key, Description ("The CollectionOfMSEs.") ]
   CIM_CollectionOfMSEs REF Collection;
        [Key, Description (
         "The Configuration object that groups the Settings and "
         "dependencies associated with the Collection.") ]
   CIM_Configuration REF Configuration;
};

// ===================================================================
//    Setting
// ===================================================================
        [Abstract, Description (
         "The Setting class represents configuration-related and "
         "operational parameters for one or more ManagedSystem"
         "Element(s). A ManagedSystemElement may have multiple Setting "
         "objects associated with it. The current operational values "
         "for an Element's parameters are reflected by properties in "
         "the Element itself or by properties in its associations. "
         "These properties do not have to be the same values present "
         "in the Setting object. For example, a modem may have a "
         "Setting baud rate of 56Kb/sec but be operating "
         "at 19.2Kb/sec.") ]
class CIM_Setting : CIM_ManagedElement
{
        [MaxLen (256), Description (
         "The identifier by which the Setting object is known.") ]
   string SettingID;
         [Description (
         "The VerifyOKToApplyToMSE method is used to verify that "
         "this Setting can be 'applied' to the referenced Managed"
         "SystemElement, at the given time or time interval. This "
         "method takes three input parameters: MSE (the Managed"
         "SystemElement that is being verified), TimeToApply (which, "
         "being a datetime, can be either a specific time or a time "
         "interval), and MustBeCompletedBy (which indicates the "
         "required completion time for the method). The return "
         "value should be 0 if it is OK to apply the Setting, 1 if "
         "the method is not supported, 2 if the Setting can not be "
         "applied within the specified times, 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 VerifyOKToApplyToMSE([IN] CIM_ManagedSystemElement ref MSE, 
    [IN] datetime TimeToApply, [IN] datetime MustBeCompletedBy);
        [Description (
         "The ApplyToMSE method performs the actual application of "
         "the Setting to the referenced ManagedSystemElement. It "
         "takes three input parameters: MSE (the ManagedSystem"
         "Element to which the Setting is being applied), "
         "TimeToApply (which, being a datetime, can be either a "
         "specific time or a time interval), and MustBeCompletedBy "
         "(which indicates the required completion time for the "
         "method). Note that the semantics of this method are that "
         "individual Settings are either wholly applied or not "
         "applied at all to their target ManagedSystemElement. The "
         "return value should be 0 if the Setting is successfully "
         "applied to the referenced ManagedSystemElement, 1 if the "
         "method is not supported, 2 if the Setting was not applied "
         "within the specified times, 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.\n"
         "Note: If an error occurs in applying the Setting to a "
         "ManagedSystemElement, the Element must be configured as "
         "when the 'apply' attempt began. That is, the Element "
         "should NOT be left in an indeterminate state.") ]
   uint32 ApplyToMSE([IN] CIM_ManagedSystemElement ref MSE, 
    [IN] datetime TimeToApply, [IN] datetime MustBeCompletedBy);
        [Description (
         "The VerifyOKToApplyToCollection method is used to verify "
         "that this Setting can be 'applied' to the referenced "
         "Collection of ManagedSystemElements, at the given time "
         "or time interval, without causing adverse effects to "
         "either the Collection itself or its surrounding "
         "environment. The net effect is to execute the "
         "VerifyOKToApply method against each of the Elements "
         "aggregated by the Collection. This method takes three "
         "input parameters: Collection (the Collection of Managed"
         "SystemElements that is being verified), TimeToApply (which, "
         "being a datetime, can be either a specific time or a time "
         "interval), and MustBeCompletedBy (which indicates the "
         "required completion time for the method). The return "
         "value should be 0 if it is OK to apply the Setting, 1 if "
         "the method is not supported, 2 if the Setting can not be "
         "applied within the specified times, and any other number if "
         "an error occurred. One output parameter is defined - "
         "CanNotApply - which is a string array that lists the keys of "
         "the ManagedSystemElements to which the Setting can NOT be "
         "applied. This enables those Elements to be revisited and "
         "either fixed, or other corrective action taken.\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 VerifyOKToApplyToCollection (
    [IN] CIM_CollectionOfMSEs ref Collection,
    [IN] datetime TimeToApply, [IN] datetime MustBeCompletedBy,
    [OUT] string CanNotApply[]);
        [Description (
         "The ApplyToCollection method performs the application of "
         "the Setting to the referenced Collection of ManagedSystem"
         "Elements. The net effect is to execute the ApplyToMSE "
         "method against each of the Elements aggregated by the "
         "Collection. If the input value ContinueOnError is FALSE, "
         "this method applies the Setting to all Elements in the "
         "Collection until it encounters an error, in which case it "
         "stops execution, logs the key of the Element that caused "
         "the error in the CanNotApply array, and issues a return code "
         "of 2. If the input value ContinueOnError is TRUE, then this "
         "method applies the Setting to all the ManagedSystemElements "
         "in the Collection, and reports the failed Elements in the "
         "array, CanNotApply. For the latter, processing will continue "
         "until the method is applied to all Elements in the "
         "Collection, regardless of any errors encountered. The key of "
         "each ManagedSystemElement to which the Setting could not be "
         "applied is logged into the CanNotApply array. This method "
         "takes four input parameters: Collection (the Collection of "
         "Elements to which the Setting is being applied), TimeToApply "
         "(which, being a datetime, can be either a specific time or a "
         "time interval), ContinueOnError (TRUE means to continue "
         "processing on encountering an error), and MustBeCompletedBy "
         "(which indicates the required completion time for the "
         "method). The return value should be 0 if the Setting is "
         "successfully applied to the referenced Collection, 1 if the "
         "method is not supported, 2 if the Setting was not applied "
         "within the specified times, 3 if the Setting can not be "
         "applied using the input value for ContinueOnError, and any "
         "other number if an error occurred. One output parameter is "
         "defined, CanNotApplystring, which is an array that lists "
         "the keys of the ManagedSystemElements to which the Setting "
         "was NOT able to be applied. This output parameter has "
         "meaning only when the ContinueOnError parameter is TRUE.\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.\n"
         "Note: if an error occurs in applying the Setting to a "
         "ManagedSystemElement in the Collection, the Element must be "
         "configured as when the 'apply' attempt began. That is, the "
         "Element should NOT be left in an indeterminate state.") ]
   uint32 ApplyToCollection([IN] CIM_CollectionOfMSEs ref Collection, 
    [IN] datetime TimeToApply, [IN] boolean ContinueOnError,
    [IN] datetime MustBeCompletedBy, [OUT] string CanNotApply[]);
};

// ===================================================================
//    ElementSetting
// ===================================================================
        [Association, Description (
         "ElementSetting represents the association between Managed"
         "SystemElements and the Setting class(es) defined for them.") ]
class CIM_ElementSetting
{
        [Key, Description ("The ManagedSystemElement.") ]
   CIM_ManagedSystemElement REF Element;
        [Key, Description (
         "The Setting object associated with the ManagedSystem"
         "Element.") ]
   CIM_Setting REF Setting;
};

// ===================================================================
//    DefaultSetting
// ===================================================================
        [Association, Description (
         "DefaultSetting represents the association between a Managed"
         "SystemElement and the single Setting class that is defined "
         "to be the default setting for this Element.") ]
class CIM_DefaultSetting : CIM_ElementSetting
{
        [Override ("Setting"), Max (1), Description (
         "The Setting object which is the default.") ]
   CIM_Setting REF Setting;
};

// ===================================================================
//    SettingContext
// ===================================================================
        [Association, Aggregation, Description (
         "This relationship associates Configuration objects with "
         "Setting objects. For example, a NetworkAdapter's Settings "
         "could change based on the site/network to which its hosting "
         "ComputerSystem is attached. In this case, the ComputerSystem "
         "would have two different Configuration objects, corresponding "
         "to the differences in network configuration for the two network "
         "segments. Configuration A would aggregate a Setting object for "
         "the NetworkAdapter when operating on segment \"ANet\", whereas "
         "Configuration B would aggregate a different NetworkAdapter "
         "Setting object, specific to segment \"BNet\". Note that many "
         "Settings of the computer are independent of the network "
         "Configuration. For example, both Configurations A and B would "
         "aggregate the same Setting object for the ComputerSystem's "
         "MonitorResolution.") ]
class CIM_SettingContext
{
        [Aggregate, Key, Description (
         "The Configuration object that aggregates the Setting.") ]
   CIM_Configuration REF Context;
        [Key, Description ("An aggregated Setting.")]
   CIM_Setting REF Setting;
};

// ===================================================================
//    CollectionSetting
// ===================================================================
        [Association, Description (
         "CollectionSetting represents the association between a "
         "CollectionOfMSEs class and the Setting class(es) defined for "
         "them.") ]
class CIM_CollectionSetting
{
        [Key, Description ("The CollectionOfMSEs.") ]
   CIM_CollectionOfMSEs REF Collection;
        [Key, Description (
         "The Setting object associated with the Collection.") ]
   CIM_Setting REF Setting;
};

// ==================================================================
//    System
// ==================================================================
        [Abstract, Description (
         "A CIM_System is a LogicalElement that aggregates an "
         "enumerable set of Managed System Elements. The aggregation "
         "operates as a functional whole. Within any particular "
         "subclass of System, there is a well-defined list of "
         "Managed System Element classes whose instances must be "
         "aggregated.") ] 
class CIM_System:CIM_LogicalElement
{
        [Key, MaxLen (256), Description (
         "CreationClassName indicates the name of the class or the "
         "subclass used in the creation of an instance. When used "
         "with the other key properties of this class, this property "
         "allows all instances of this class and its subclasses to "
         "be uniquely identified.") ]
    string CreationClassName;
        [Key, MaxLen (256), Override ("Name"), Description (
         "The inherited Name serves as key of a System instance in " 
         "an enterprise environment.") ] 
    string Name;
        [MaxLen (64), Description (
         "The System object and its derivatives are Top Level Objects "
         "of CIM. They provide the scope for numerous components. " 
         "Having unique System keys is required. A heuristic can be "
         "defined in individual System subclasses to attempt to always "
         "generate the same System Name Key. The NameFormat property "
         "identifies how the System name was generated, using "
         "the subclass' heuristic.") ] 
    string NameFormat;
        [MaxLen (256), Description (
         "A string that provides information on how the primary system "
         "owner can be reached (e.g. phone number, email address, "
	   "...)."),
         MappingStrings {"MIF.DMTF|General Information|001.3"} ] 
    string PrimaryOwnerContact;
        [MaxLen (64), Description (
	   "The name of the primary system owner."),
         MappingStrings {"MIF.DMTF|General Information|001.4"} ]  
    string PrimaryOwnerName;
        [Description (
         "An array (bag) of strings that specify the roles this System "
         "plays in the IT-environment. Subclasses of System may "
         "override this property to define explicit Roles values. "
         "Alternately, a Working Group may describe the heuristics, "
         "conventions and guidelines for specifying Roles. For "
         "example, for an instance of a networking system, the Roles "
         "property might contain the string, 'Switch' or 'Bridge'.") ]
    string Roles[];
};

// ===================================================================
//    ComputerSystem
// ===================================================================
	  [Abstract, Description (
         "A class derived from System that is a special collection of "
         "ManagedSystemElements. This collection provides "
         "compute capabilities and serves as aggregation point to "
         "associate one or more of the following elements: FileSystem, "
         "OperatingSystem, Processor and Memory (Volatile and/or "
         "NonVolatile Storage).") ] 
class CIM_ComputerSystem : CIM_System
{
        [Override ("NameFormat"), Description (
 	   "The ComputerSystem object and its derivatives are Top Level "
	   "Objects of CIM. They provide the scope for numerous "
	   "components. Having unique System keys is required. "
	   "A heuristic is defined to create the ComputerSystem Name "
	   "to attempt to always generate the same Name, independent of "
	   "discovery protocol. This prevents inventory and management "
	   "problems where the same asset or entity is discovered "
	   "multiple times, but can not be resolved to a single object. "
	   "Use of the heuristic is optional, but recommended.\n\n"
	   "The NameFormat property identifies how the ComputerSystem "
	   "Name is generated, using a heuristic. The heuristic is "
	   "outlined, in detail, in the CIM V2 System Model spec. "
	   "It assumes that the documented rules are traversed in order, "
	   "to determine and assign a Name. The NameFormat Values "
	   "list defines the precedence order for assigning the Computer"
	   "System Name. Several rules do map to the same Value.\n\n"
	   "Note that the ComputerSystem Name calculated using the "
	   "heuristic is the System's key value. Other names can be "
	   "assigned and used for the ComputerSystem, that better suit "
	   "a business, using Aliases."), 
         ValueMap {"Other", "IP", "Dial", "HID", "NWA", "HWA", "X25", 
	       "ISDN", "IPX", "DCC", "ICD", "E.164", "SNA", "OID/OSI"} ]
   string NameFormat;
        [MaxLen (256), ArrayType ("Indexed"), 
         Description (
         "OtherIdentifyingInfo captures additional data, beyond "
         "System Name information, that could be used to identify "
         "a ComputerSystem. One example would be to hold the "
         "Fibre Channel World-Wide Name (WWN) of a node. Note that "
         "if only the Fibre Channel name is available and is "
         "unique (able to be used as the System key), then this "
         "property would be NULL and the WWN would become the "
         "System key, its data placed in the Name property."),
         ModelCorrespondence {
          "CIM_ComputerSystem.IdentifyingDescriptions"} ]
   string OtherIdentifyingInfo[];
        [ArrayType ("Indexed"), Description (
         "An array of free-form strings providing explanations "
         "and details behind the entries in the OtherIdentifying"
         "Info array. Note, each entry of this array is related "
         "to the entry in OtherIdentifyingInfo that is located at "
         "the same index."),
         ModelCorrespondence {
          "CIM_ComputerSystem.OtherIdentifyingInfo"} ]
   string IdentifyingDescriptions[];
        [Description (
         "Enumeration indicating whether the ComputerSystem is "
         "a special-purpose System (ie, dedicated to a particular "
         "use), versus being 'general purpose'. For example, one "
         "could specify that the System is dedicated to \"Print\" "
         "(value=11) or acts as a \"Hub\" (value=8)."),
         Values {"Not Dedicated", "Unknown", "Other", "Storage", 
          "Router", "Switch", "Layer 3 Switch", 
          "Central Office Switch", "Hub", "Access Server", 
          "Firewall", "Print", "I/O", "Web Caching", "Management"} ]
   uint16 Dedicated[];
};
     
// ===================================================================
//    LogicalDevice
// ===================================================================
        [Abstract, Description (
         "An abstraction or emulation of a hardware entity, that may "
         "or may not be Realized in physical hardware. Any "
	   "characteristics of a LogicalDevice that are used to manage "
	   "its operation or configuration are contained in, or "
	   "associated with, the LogicalDevice object. Examples of the "
	   "operational properties of a Printer would be paper sizes "
	   "supported, or detected errors. Examples of the configuration "
	   "properties of a Sensor Device would be threshold settings. "
	   "Various configurations could exist for a LogicalDevice. "
	   "These configurations could be contained in Setting objects "
	   "and associated with the LogicalDevice.") ] 
class CIM_LogicalDevice:CIM_LogicalElement
{
        [Propagated("CIM_System.CreationClassName"), 
         Key, MaxLen (256),
         Description ("The scoping System's CreationClassName.") ]
   string SystemCreationClassName;
        [Propagated("CIM_System.Name"),
         Key, MaxLen (256),
         Description ("The scoping System's Name.") ]
   string SystemName;
        [Key, MaxLen (256),
         Description (
         "CreationClassName indicates the name of the class or "
         "the subclass used in the creation of an instance. When "
         "used with the other key properties of this class, this "
         "property allows all instances of this class and its "
         "subclasses to be uniquely identified.") ]
   string CreationClassName;
        [Key, MaxLen (64),
         Description (
         "An address or other identifying information to uniquely "
         "name the LogicalDevice.") ]
   string DeviceID;
        [Description (
         "Boolean indicating that the Device can be power managed "
         "- ie, put into a power save state. 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 "
         "LogicalDevice. The array 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 Device 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"} ]
   uint16 PowerManagementCapabilities[];
        [Description (
		"The primary availability and status of the Device. (Additional "
		"status information can be specified using the AdditionalAvailability "
		"array property.) For example, the Availability property indicates "
		"that the Device is running and has full power (value=3), or is in "
		"a warning (4), test (5), degraded (10) or power save state (values "
		"13-15 and 17). Regarding the Power Save states, these are defined "
         "as follows: Value 13 (\"Power Save - Unknown\") indicates "
	   "that the Device is known to be in a power save mode, but its "
	   "exact status in this mode is unknown; 14 (\"Power Save - Low "
	   "Power Mode\") indicates that the Device is in a power save "
	   "state but still functioning, and may exhibit degraded "
	   "performance; 15 (\"Power Save - Standby\") describes that "
	   "the Device is not functioning but could be brought to full "
	   "power 'quickly'; and value 17 (\"Power Save - Warning\") "
	   "indicates that the Device is in a warning state, though also "
	   "in a power save mode."), 
	   	   ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9",
	       "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"
		   "20", "21"},
       Values {"Other", "Unknown", "Running/Full Power", "Warning", 
	       "In Test", "Not Applicable", "Power Off", "Off Line", 
	       "Off Duty", "Degraded", "Not Installed", "Install Error",
	       "Power Save - Unknown", "Power Save - Low Power Mode", 
	       "Power Save - Standby", "Power Cycle","Power Save - Warning", 
		   "Paused", "Not Ready", "Not Configured", "Quiesced"}, 
       MappingStrings {"MIF.DMTF|Operational State|004.5",
          "MIB.IETF|HOST-RESOURCES-MIB.hrDeviceStatus", 
          "MIF.DMTF|Host Device|001.5"},
		  ModelCorrespondence {"CIM_LogicalDevice.AdditionalAvailability"}]
   uint16 Availability;
        [Description (
         "StatusInfo is a string indicating whether the Logical"
         "Device is in an enabled (value = 3), disabled (value = "
         "4) or some other (1) or unknown (2) state. If this "
         "property does not apply to the LogicalDevice, the value, "
         "5 (\"Not Applicable\"), should be used. "
		"If a Device is (\"Enabled\")(value=3), it has been powered up, and is "
        "configured and operational. The Device may or may not be functionally "
        "active, depending on whether its Availability (or AdditionalAvailability) "
        "indicate that it is (\"Running/Full Power\")(value=3) or (\"Off line\")"
        "(value=8). In an enabled but offline mode, a Device may be performing "
        "out-of-band requests, such as running Diagnostics. If (\"Disabled\")"
        "(StatusInfo value=4), a Device can only be \"enabled\" or powered off. "
        "In a personal computer environment, (\"Disabled\") means that the "
        "Device's driver is not available in the stack. In other environments, "
        "a Device can be disabled by removing its configuration file. A "
        "disabled device is physically present in a System and consuming "
        "resources, but can not be communicated with until a load of a driver, "
        "a load of a configuration file or some other \"enabling\" activity has "
        "occurred."),
         ValueMap {"1", "2", "3", "4", "5"},
         Values {"Other", "Unknown", "Enabled",
	       "Disabled", "Not Applicable"},
         MappingStrings {"MIF.DMTF|Operational State|004.3"} ]
   uint16 StatusInfo;
	  [Description (
	   "LastErrorCode captures the last error code reported by " 
	   "the LogicalDevice.")]
   uint32 LastErrorCode;
	  [Description (
	   "ErrorDescription is a free-form string supplying more " 
	   "information about the error recorded in LastErrorCode, and " 
	   "information on any corrective actions that may be taken.")]
   string ErrorDescription;
	  [Description (
	   "ErrorCleared is a boolean property indicating that the " 
	   "error reported in LastErrorCode is now cleared.")]
   boolean ErrorCleared;
        [MaxLen (256), ArrayType ("Indexed"), 
         Description (
         "OtherIdentifyingInfo captures additional data, beyond "
         "DeviceID information, that could be used to identify a "
         "LogicalDevice. One example would be to hold the Operating"
         "System's user friendly name for the Device in this "
         "property."),
         ModelCorrespondence {
           "CIM_LogicalDevice.IdentifyingDescriptions"} ]
   string OtherIdentifyingInfo[];
        [Description (
         "The number of consecutive hours that this Device has been "
         "powered, since its last power cycle."),
         Units ("Hours"), Counter ]
   uint64 PowerOnHours;
        [Description (
         "The total number of hours that this Device has been "
         "powered."),
         Units ("Hours"), Counter ]
   uint64 TotalPowerOnHours;
        [ArrayType ("Indexed"), Description (
         "An array of free-form strings providing explanations "
         "and details behind the entries in the OtherIdentifyingInfo "
         "array. Note, each entry of this array is related to the "
         "entry in OtherIdentifyingInfo that is located at the same "
         "index."),
         ModelCorrespondence {"CIM_LogicalDevice.OtherIdentifyingInfo"} ]
   string IdentifyingDescriptions[];
		[Description (
         "Additional availability and status of the Device, beyond that "
         "specified in the Availability property. The Availability property "
         "denotes the primary status and availability of the Device. In "
         "some cases, this will not be sufficient to denote the complete "
         "status of the Device.  In those cases, the AdditionalAvailability "
         "property can be used to provide further information. For example, "
         "a Device's primary Availability may be \"Off line\" (value=8), "
         "but it may also be in a low power state (AdditonalAvailability "
         "value=14), or the Device could be running Diagnostics (Additional"
         "Availability value=5, \"In Test\")."),
         ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9",
             "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", 
             "20", "21"},
         Values {"Other", "Unknown", "Running/Full Power", "Warning", 
             "In Test", "Not Applicable", "Power Off", "Off Line", 
             "Off Duty", "Degraded", "Not Installed", "Install Error",
             "Power Save - Unknown", "Power Save - Low Power Mode", 
             "Power Save - Standby", "Power Cycle", 
             "Power Save - Warning", "Paused", "Not Ready",
             "Not Configured", "Quiesced"}, 
         ModelCorrespondence {"CIM_LogicalDevice.Availability"}]
   uint16 AdditionalAvailability[];
		[Description (
         "Maximum time in milliseconds, that a Device can run in a \"Quiesced\" "
         "state. A Device's state is defined in its Availability and Additional"
         "Availability properties, where \"Quiesced\" is conveyed by the value "
         "21. What occurs at the end of the time limit is device-specific. The "
         "Device may unquiesce, may offline or take other action. A value of 0 "
         "indicates that a Device can remain quiesced indefinitely."), 
		Units ("MilliSeconds")]
   uint64 MaxQuiesceTime;
        [Description(
         "SetPowerState defines the desired power state for a "
         "LogicalDevice and when a Device should be put into that "
         "state. The desired power state is specified by setting "
	   "the PowerState parameter to 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\" or 6=\"Power 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 Device should power on again. Power off is "
	   "immediate. SetPowerState should return 0 if successful, 1 "
	   "if the specified PowerState 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"},
    Values {"Full Power", "Power Save - Low Power Mode", 
    "Power Save - Standby", "Power Save - Other", "Power Cycle",
    "Power Off"}] uint16 PowerState, [IN] datetime Time);
        [Description (
         "Requests a reset of the LogicalDevice. 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 Reset();
        [Description (
         "Requests that the LogicalDevice be enabled (\"Enabled\" "
         "input parameter = TRUE) or disabled (= FALSE). If "
         "successful, the Device's StatusInfo property should also "
         "reflect the desired state (enabled/disabled). The return "
         "code 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 EnableDevice([IN] boolean Enabled);
		[Description (
         "Requests that the LogicalDevice be brought online (\"Online\" "
         "input parameter = TRUE) or taken offline (= FALSE). "
         "\"Online\" indicates that the Device is ready to accept "
         "requests, and is operational and fully functioning. In this "
         "case, the Device's Availability property would be set to "
         "a value of 3 (\"Running/Full Power\"). \"Offline\" indicates "
         "that a Device is powered up and operational, but not processing "
         "functional requests. In an offline state, a Device may be capable "
         "of running diagnostics or generating operational alerts. For "
         "example, when the \"Offline\" button is pushed on a Printer, the "
         "Device is no longer available to process print jobs, but "
         "could be available for diagnostics or maintenance.\n"
         "If this method is successful, the Device's Availability and "
         "AdditionalAvailability properties should reflect the updated "
         "status. If a failure occurs trying to bring the Device online "
         "or offline, it should remain in its current state. IE, the "
         "request, if unsuccessful, should not leave the Device in an "
         "indeterminate state. When bringing a Device back \"Online\", "
         "from an \"Offline\" mode, the Device should be restored to its "
         "last \"Online\" state, if at all possible. Only a Device that "
         "has a StatusInfo of \"Enabled\" (value=3) and has been "
         "configured can be brought online or taken offline.\n"
         "OnlineDevice should return 0 if successful, 1 if the request is not "
         "supported at all, 2 if the request is not supported due to the "
         "current state of the Device, 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 OnlineDevice([IN] boolean Online);
        [Description (
         "Requests that the LogicalDevice cleanly cease all current activity " 
         "(\"Quiesce\" input parameter = TRUE) or resume activity (= FALSE). For "
         "this method to quiesce a Device, that Device should have an Availability "
         "(or AdditionalAvailability) of \"Running/Full Power\" (value=3) and a Status"
         "Info of \"Enabled\" (value=3). For example, if quiesced, a Device may "
         "then be offlined for diagnostics, or disabled for power off and hot swap. "
         "For the method to \"unquiesce\" a Device, that Device should have an "
         "Availability (or AdditionalAvailability) of \"Quiesced\" (value=21) and "
         "a StatusInfo of \"Enabled\" (value=3). In this case, the Device would "
         "be returned to an \"Enabled\" and \"Running/Full Power\" status.\n"
         "The method's return code should indicate the success or failure of the "
         "quiesce. It should return 0 if successful, 1 if the request is not "
         "supported at all, 2 if the request is not supported due to the "
         "current state of the Device, 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 QuiesceDevice([IN] boolean Quiesce);
        [Description (
         "Requests that the Device capture its current configuration, setup "
         "and/or state information in a backing store. The goal would be to "
         "use this information at a later time (via the RestoreProperties method), "
         "to return a Device to its present \"condition\". This method may not be "
         "supported by all Devices. The method should return 0 if successful, "
         "1 if the 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 SaveProperties();
        [Description (
         "Requests that the Device re-establish its configuration, setup "
         "and/or state information from a backing store. The intent is to "
         "capture this information at an earlier time (via the SaveProperties method), "
         "and use it to return a Device to this earlier \"condition\". This method may "
         "not be supported by all Devices. The method should return 0 if successful, "
         "1 if the 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 RestoreProperties();        
};  
   
// ==================================================================
//    Service
// ==================================================================  
        [Abstract, Description (
         "A CIM_Service is a Logical Element that contains the "
         "information necessary to represent and manage the "
         "functionality provided by a Device and/or SoftwareFeature. "
         "A Service is a general-purpose object to configure and "
         "manage the implementation of functionality.  It is not the "
         "functionality itself.") ] 
class CIM_Service:CIM_LogicalElement
{
        [Key, MaxLen (256), Description (
	   "CreationClassName indicates the name of the class or the "
	   "subclass used in the creation of an instance. When used "
	   "with the other key properties of this class, this property "
	   "allows all instances of this class and its subclasses to "
	   "be uniquely identified.") ]
    string CreationClassName;
        [Override ("Name"), Key, MaxLen (256),
         Description (
         "The Name property uniquely identifies the Service and "
         "provides an indication of the functionality that is "
         "managed. This functionality is described in more detail in "
         "the object's Description property. ") ] 
    string Name;
        [MaxLen (10), Description (
         "StartMode is a string value indicating whether the Service "
         "is automatically started by a System, Operating System, etc. "
         "or only started upon request."), 
	   ValueMap {"Automatic", "Manual"} ] 
    string StartMode;
        [Description (
         "Started is a boolean indicating whether the Service "
         "has been started (TRUE), or stopped (FALSE).") ] 
    boolean Started;
        [Propagated ("CIM_System.CreationClassName"), Key, 
	   MaxLen (256), Description (
         "The scoping System's CreationClassName. ") ] 
    string SystemCreationClassName;
        [Propagated ("CIM_System.Name"), Key, MaxLen (256),
         Description ("The scoping System's Name.") ] 
    string SystemName;
        [Description (
         "The StartService method places the Service in the started "
         "state. It returns an integer value of 0 if the Service was "
         "successfully started, 1 if the request is not supported and "
         "any other number to indicate an error. In a subclass, the "
         "set of possible return codes could be specified, using a "
         "ValueMap qualifier on the method. The strings to which the "
         "ValueMap contents are 'translated' may also be specified in "
         "the subclass as a Values array qualifier.") ] 
    uint32 StartService();
        [Description (
         "The StopService method places the Service in the stopped "
         "state. It returns an integer value of 0 if the Service was "
         "successfully stopped, 1 if the request is not supported and "
         "any other number to indicate an error. In a subclass, the "
         "set of possible return codes could be specified, using a "
         "ValueMap qualifier on the method. The strings to which the "
         "ValueMap contents are 'translated' may also be specified in "
         "the subclass as a Values array qualifier.") ] 
    uint32 StopService();
};
     
// ==================================================================
//    ServiceAccessPoint
// ==================================================================
        [Abstract, Description (
         "CIM_ServiceAccessPoint represents the ability to utilize or "
         "invoke a Service.  Access points represent that a Service is "
         "made available to other entities for use.") ] 
class CIM_ServiceAccessPoint:CIM_LogicalElement
{
        [Key, MaxLen (256), Description (
	   "CreationClassName indicates the name of the class or the "
         "subclass used in the creation of an instance. When used "
	   "with the other key properties of this class, this property "
	   "allows all instances of this class and its subclasses to "
	   "be uniquely identified.") ]
    string CreationClassName;
        [Override ("Name"), Key, MaxLen (256),
         Description (
         "The Name property uniquely identifies the ServiceAccessPoint "
         "and provides an indication of the functionality that is "
         "managed.  This functionality is described in more detail in "
         "the object's Description property.") ] 
    string Name;
        [Propagated ("CIM_System.CreationClassName"), Key, 
	   MaxLen (256), Description (
         "The scoping System's CreationClassName.") ] 
    string SystemCreationClassName;
        [Propagated ("CIM_System.Name"), Key, MaxLen (256),
	   Description ("The scoping System's Name.") ] 
    string SystemName;
};
     
// ==================================================================
// Dependency   
// ==================================================================
	[Association, Abstract, Description (   
	"CIM_Dependency is a generic association used to establish "   
	"dependency relationships between ManagedElements.") ]    
class CIM_Dependency    
{   
	[Key, Description (   
	"Antecedent represents the independent object in this "   
	"association.") ]    
  CIM_ManagedElement REF Antecedent;   
	[Key, Description (   
    "Dependent represents the object dependent on the "   
    "Antecedent.") ]    
  CIM_ManagedElement REF Dependent;   
};   
                 
// ==================================================================
// MemberOfCollection    
// ==================================================================
	[Association, Aggregation, Description (   
	"CIM_MemberOfCollection is an aggregation used to establish "   
	"membership of ManagedElements in a Collection." ) ]  
class CIM_MemberOfCollection  
{   
	[Key, Aggregate, Description ("The Collection that aggregates members") ]    
  CIM_Collection REF Collection;
	[Key, Description ("The aggregated member of the collection.") ]    
  CIM_ManagedElement REF Member;   
};   

// ==================================================================
//    CollectedMSEs
// ==================================================================
        [Association, Aggregation, Description (
         "CIM_CollectedMSEs is a generic association used to "
         "establish the members of the grouping object, CollectionOf"
         "MSEs.") ]
class CIM_CollectedMSEs : CIM_MemberOfCollection
{
        [Aggregate, Description (
         "The grouping or 'bag' object that represents the "
         "Collection."), Override("Collection") ]
   CIM_CollectionOfMSEs REF Collection;
        [Description ("The members of the Collection."),
	 Override("Member") ]
   CIM_ManagedSystemElement REF Member;
};

// ===================================================================
//    DependencyContext
// ===================================================================
        [Association, Aggregation, Description (
         "This relationship associates a Dependency with one or more "
         "Configuration objects. For example, a ComputerSystem's "
         "dependencies could change based on the site/network to which "
         "the System is attached.") ]
class CIM_DependencyContext
{
        [Aggregate, Key, Description (
         "The Configuration object that aggregates the Dependency.") ]
   CIM_Configuration REF Context;
        [Key, Description ("An aggregated Dependency.") ]
   CIM_Dependency REF Dependency;
};
     
// ==================================================================
//    ServiceAccessBySAP
// ==================================================================
        [Association, Description (
         "CIM_ServiceAccessBySAP is an association that identifies the "
         "access points for a Service. For example, a printer may be "
         "accessed by Netware, MacIntosh or Windows ServiceAccess"
         "Points, potentially hosted on different Systems.") ] 
class CIM_ServiceAccessBySAP:CIM_Dependency
{
        [Override ("Antecedent"),
	   Description ("The Service. ") ] 
    CIM_Service REF Antecedent;
        [Override ("Dependent"), Description (
	   "An Access Point for a Service. Access points are dependent " 
         "in this relationship since they have no function without a "
         "corresponding Service. ") ] 
    CIM_ServiceAccessPoint REF Dependent;
};
     
// ==================================================================
//    HostedService
// ==================================================================
        [Association, Description (
         "CIM_HostedService is an association between a Service and "
         "the System on which the functionality resides.  The "
         "cardinality of this association is 1-to-many.  A System may "
         "host many Services. Services are weak with respect to their "
         "hosting System. Heuristic:  A Service is hosted on the "
         "System where the LogicalDevices or SoftwareFeatures that "
         "implement the Service are located.  The model does not "
         "represent Services hosted across multiple systems.  This is "
         "modeled as an ApplicationSystem that acts as an aggregation "
         "point for Services, that are each located on a single "
         "host.") ] 
class CIM_HostedService:CIM_Dependency
{
        [Override ("Antecedent"), Max (1), Min (1),
	   Description ("The hosting System.") ] 
    CIM_System REF Antecedent;
        [Override ("Dependent"), Weak,
         Description ("The Service hosted on the System.") ] 
    CIM_Service REF Dependent;
};
     
// ==================================================================
//    HostedAccessPoint
// ==================================================================
        [Association, Description (
         "CIM_HostedAccessPoint is an association between a Service"
         "AccessPoint and the System on which it is provided.  The "
         "cardinality of this association is 1-to-many and is weak "
         "with respect to the System. Each System may host many "
	   "ServiceAccessPoints.  Heuristic:  If the implementation of "
         "the ServiceAccessPoint is modeled, it must be "
         "implemented by a Device or SoftwareFeature that is part of "
         "the System hosting the ServiceAccessPoint.") ] 
class CIM_HostedAccessPoint:CIM_Dependency
{
        [Override ("Antecedent"), Max (1), Min (1), 
	   Description ("The hosting System.") ] 
    CIM_System REF Antecedent;
        [Override ("Dependent"), Weak,
	 Description ("The SAP(s) that are hosted on this System.") ] 
    CIM_ServiceAccessPoint REF Dependent;
};
   

// ==================================================================
//    ServiceServiceDependency
// ==================================================================
        [Association, Description (
         "CIM_ServiceServiceDependency is an association between a " 
         "Service and another Service, indicating that the latter is "
         "required to be present, required to have completed, or must " 
         "be absent for the former Service to provide its "
         "functionality. For example, Boot Services may be dependent "
         "upon underlying BIOS Disk and initialization Services. "
         "In the case of the initialization Services, the Boot Service "
         "is simply dependent on the init Services completing.  For "
         "the Disk Services, Boot Services may actually utilize the "
          "SAPs of this Service.  This usage dependency is modeled via "
         "the CIM_ServiceSAPDependency association.") ] 
class CIM_ServiceServiceDependency:CIM_Dependency
{
        [Override ("Antecedent"), 
           Description ("The required Service.") ] 
    CIM_Service REF Antecedent;
        [Override ("Dependent"), Description (
         "The Service that is dependent on an underlying Service.") ] 
    CIM_Service REF Dependent;
          [Description (
         "The nature of the Service to Service dependency. This "
           "property describes that the associated Service must have "
           "completed (value=2), must be started (3) or must not be "
           "started (4) in order for the Service to function."),  
           Values {"Unknown", "Other", "Service Must Have Completed",
                 "Service Must Be Started", 
                 "Service Must Not Be Started"} ]
    uint16 TypeOfDependency;
		[Description(
         "this property describes that the antecedent service "
         "must be restarted after the dependent operation is complete.")]
    boolean RestartService;
};

// ==================================================================
//    ServiceSAPDependency
// ==================================================================
        [Association, Description (
         "CIM_ServiceSAPDependency is an association between a Service "
         "and a ServiceAccessPoint indicating that the referenced SAP "
         "is utilized by the Service to provide its functionality. For "
         "example, Boot Services may invoke BIOS' Disk Services "
         "(interrupts) in order to function.") ] 
class CIM_ServiceSAPDependency:CIM_Dependency
{
        [Override ("Antecedent"), 
	   Description ("The required ServiceAccessPoint") ] 
    CIM_ServiceAccessPoint REF Antecedent;
        [Override ("Dependent"), Description (
         "The Service that is dependent on an underlying SAP.") ] 
    CIM_Service REF Dependent;
};
     
// ==================================================================
//    SAPSAPDependency
// ==================================================================
        [Association, Description (
         "CIM_SAPSAPDependency is an association between a Service"
         "AccessPoint and another ServiceAccessPoint indicating that "
         "the latter is required in order for the former ServiceAccess"
         "Point to utilize or connect with its Service. For example, "
         "to print at a network printer, local Print Access Points "
         "must utilize underlying network-related SAPs, or "
         "ProtocolEndpoints, in order to send the print request.") ] 
class CIM_SAPSAPDependency:CIM_Dependency
{
        [Override ("Antecedent"), Description (
         "The required ServiceAccessPoint.") ] 
    CIM_ServiceAccessPoint REF Antecedent;
        [Override ("Dependent"), Description (
         "The ServiceAccessPoint that is dependent on an underlying "
         "SAP.") ] 
    CIM_ServiceAccessPoint REF Dependent;
};

// ==================================================================
//    ProvidesServiceToElement
// ==================================================================
        [Association, Description (
         "CIM_ProvidesServiceToElement is used to describe that "
	   "ManagedSystemElements may be dependent on the functionality "
         "of one or more Services. An example is that a Processor "
         "and an Enclosure (PhysicalElement) are dependent on AlertOn"
         "LAN Services to signal an incomplete or erroneous boot, and "
         "hardware-related errors.") ]
class CIM_ProvidesServiceToElement : CIM_Dependency
{
        [Override ("Antecedent"), Description (
         "The Service provided.") ]
   CIM_Service ref Antecedent;
        [Override ("Dependent"), Description (
         "The ManagedSystemElement dependent on the Service.") ]
   CIM_ManagedSystemElement ref Dependent;
};

// ==================================================================
//    Realizes
// ==================================================================
        [Association, Description (
         "CIM_Realizes is the association that defines the mapping "
         "between a Logical Device and the physical component that "
         "implements the Device.") ] 
class CIM_Realizes:CIM_Dependency
{
	 [Override ("Antecedent"), Description (
	  "The physical component that implements the Device.") ]
    CIM_PhysicalElement REF Antecedent;
	 [Override ("Dependent"), Description ("The LogicalDevice.") ]
    CIM_LogicalDevice REF Dependent;
};
     
// ==================================================================
//    Component
// ==================================================================
        [Association, Abstract, Aggregation, Description (
         "CIM_Component is a generic association used to establish "
         "'part of' relationships between Managed System Elements. For "
         "example, the SystemComponent association defines parts of "
         "a System.") ] 
class CIM_Component
{
        [Aggregate, Key, Description (
         "The parent element in the association.") ] 
    CIM_ManagedSystemElement REF GroupComponent;
        [Key, Description ("The child element in the association.") ] 
    CIM_ManagedSystemElement REF PartComponent;
};
     
// ==================================================================
//    SystemComponent
// ==================================================================
        [Association, Aggregation, Description (
         "CIM_SystemComponent is a specialization of the CIM_Component "
         "association that establishes 'part of' relationships between "
         "a System and the Managed System Elements of which it is "
	   "composed.") ] 
class CIM_SystemComponent:CIM_Component
{
        [Override ("GroupComponent"), Aggregate, 
         Description ("The parent System in the Association.") ] 
    CIM_System REF GroupComponent;
        [Override ("PartComponent"), Description (
         "The child element that is a component of a System.") ] 
    CIM_ManagedSystemElement REF PartComponent;
};
     
// ==================================================================
//    SystemDevice
// ==================================================================
        [Association, Aggregation, Description (
	   "LogicalDevices may be aggregated by a System.  This " 
	   "relationship is made explicit by the SystemDevice "
	   "association. ") ]
class CIM_SystemDevice:CIM_SystemComponent
{
        [Override ("GroupComponent"), Aggregate, Max (1), Min (1), 
         Description ("The parent system in the Association.") ] 
    CIM_System REF GroupComponent;
        [Override ("PartComponent"), Weak, Description (
         "The LogicalDevice that is a component of a System.") ] 
    CIM_LogicalDevice REF PartComponent;
};

// ==================================================================
//    ServiceComponent
// ==================================================================
        [Association, Aggregation, Description (
         "The ServiceComponent aggregation models a set of "
         "subordinate Services that are aggregated together to form "
         "a higher-level service.") ]
class CIM_ServiceComponent : CIM_Component
{
        [Override ("GroupComponent"), Aggregate, 
         Description ("The parent Service.") ]
   CIM_Service REF GroupComponent;
        [Override ("PartComponent"), 
         Description ("The component Service.") ]
   CIM_Service REF PartComponent;
};
     
// ==================================================================
//    Product
// ==================================================================
        [Description (
         "CIM_Product is a concrete class that is a collection of "
         "PhysicalElements, SoftwareFeatures and/or other Products, "
	   "acquired as a unit. Acquisition implies an agreement "
	   "between supplier and consumer which may have implications "
	   "to Product licensing, support and warranty. Non-commercial "
         "(e.g., in-house developed Products) should also be "
         "identified as an instance of CIM_Product.") ] 
class CIM_Product : CIM_ManagedElement
{
         [Key, MaxLen (64), Description (
         "Product identification such as a serial number on software, "
         "a die number on a hardware chip, or (for non-commercial "
         "Products) a project number."), 
         MappingStrings {"MIF.DMTF|ComponentID|001.4"} ] 
    string IdentifyingNumber;
        [Key, MaxLen (256),
	   Description ("Commonly used Product name."), 
	   MappingStrings {"MIF.DMTF|ComponentID|001.2"} ] 
    string Name;
        [MaxLen (64), Description (
	   "Product SKU (stock keeping unit) information.") ] 
    string SKUNumber;
        [Key, MaxLen (256), Description (
         "The name of the Product's supplier, or entity selling the "
         "Product (the manufacturer, reseller, OEM, etc.). Corresponds "
         "to the Vendor property in the Product object in the DMTF "
         "Solution Exchange Standard."), 
         MappingStrings {"MIF.DMTF|ComponentID|001.1"} ] 
    string Vendor;
        [Key, MaxLen (64), Description (
         "Product version information.  Corresponds to the Version "
         "property in the Product object in the DMTF Solution "
         "Exchange Standard."), 
         MappingStrings {"MIF.DMTF|ComponentID|001.3"} ] 
    string Version;
		[Description (
		"If this Product is under warranty, the start date of the "
		"warranty."),
		ModelCorrespondence {"CIM_Product.WarrantyDuration"},
		MappingStrings {"MIF.DMTF|FRU|002.9"} ]
	datetime WarrantyStartDate;
		[Description (
		"If this Product is under warranty, the duration of the "
		"warranty in days."), Units ("Days"), 
		ModelCorrespondence {"CIM_Product.WarrantyStartDate"},
		MappingStrings {"MIF.DMTF|FRU|002.10"}]
	uint32 WarrantyDuration;
};
     
// ==================================================================
//    ProductParentChild
// ==================================================================
        [Association, Aggregation, Description (
         "The CIM_ProductParentChild association defines a parent "
         "child hierarchy among Products.  For example, a Product may "
         "come bundled with other Products. ") ] 
class CIM_ProductParentChild
{
        [Aggregate, Key, Description (
	   "The parent Product in the association.") ] 
    CIM_Product REF Parent;
        [Key, Description ("The child Product in the association.") ] 
    CIM_Product REF Child;
};

// ==================================================================
//    CompatibleProduct
// ================================================================== 
	  [Association, Description ( 
	   "CIM_CompatibleProduct is an association between Products " 
	   "that can indicate a wide variety of information. For " 
	   "example, it can indicate that the two referenced Products " 
	   "interoperate, that they can be installed together, that " 
	   "one can be the physical container for the other, etc. The " 
	   "string property, CompatibilityDescription, defines how the " 
	   "Products interoperate or are compatible, any limitations " 
	   "regarding interoperability or installation, ...") ]
class CIM_CompatibleProduct
{
	  [Key, Description ( 
	   "The Product for which compatible offerings are defined.") ] 
    CIM_Product REF Product; 
	  [Key, Description ("The compatible Product.") ]
    CIM_Product REF CompatibleProduct; 
	  [Description ( 
	   "CompatibilityDescription is a free-form string defining " 
	   "how the two referenced Products interoperate or are " 
	   "compatible, any limitations to compatibility, etc.") ]
    string CompatibilityDescription;
};

// ==================================================================
//    ProductProductDependency
// ================================================================== 
	  [Association, Description ( 
	   "CIM_ProductProductDependency is an association between two " 
	   "Products, indicating that one must be installed, or must be " 
	   "absent, for the other to function. This is conceptually " 
	   "equivalent to the ServiceServiceDependency association.") ] 
class CIM_ProductProductDependency
{ 
	  [Key, Description ("The required Product.") ] 
    CIM_Product REF RequiredProduct; 
	  [Key, Description ( 
	   "The Product that is dependent on another Product.") ] 
    CIM_Product REF DependentProduct; 
	  [Description ( 
	   "The nature of the Product dependency. This property " 
	   "describes that the associated Product must be installed "
         "(value=2) or must be absent (value=3) in order for the "
         "Product to function."),  
	   Values {"Unknown", "Other", "Product Must Be Installed", 
	      "Product Must Not Be Installed"} ]
    uint16 TypeOfDependency; 
};
     
// ==================================================================
//    SupportAccess
// ==================================================================
        [Description (
         "The CIM_SupportAccess association defines how to obtain "
         "assistance for a Product.") ] 
class CIM_SupportAccess : CIM_ManagedElement
{
        [Description (
         "CommunicationInfo provides the details of the Communication"
         "Mode. For example, if the CommunicationMode is 'Phone', "
         "CommunicationInfo specifies the phone number to be called."), 
         MappingStrings {"MIF.DMTF|FRU|002.11", "MIF.DMTF|FRU|002.12"} ] 
    string CommunicationInfo;
        [Description (
         "CommunicationMode defines the form of communication in order "
         "to obtain support. For example, phone communication (value"
	   "=2), fax (3) or email (8) can be specified."), 
	   ValueMap {"1", "2", "3", "4", "5", "6", "7", "8"}, 
	   Values {"Other", "Phone", "Fax", "BBS", 
               "Online Service", "Web Page", "FTP", "E-mail"}, 
         MappingStrings {"MIF.DMTF|Support|001.5"} ] 
    uint16 CommunicationMode;
        [Override ("Description"), Description (
	   "A textual description of the type of Support provided."),
	   MappingStrings {"MIF.DMTF|Support|001.3"} ] 
    string Description;
        [MaxLen (64), Description (
         "Locale defines the geographic region and/or language dialect "
         "to which this Support resource pertains."), 
	   MappingStrings {"MIF.DMTF|Support|001.2"} ] 
    string Locale;
        [Key, MaxLen (256), Description (
         "SupportAccessID is an arbitrary, free form string defined by "
         "the Product Vendor or by the organization that deploys the "
         "Product.  This property, since it is a key, should be unique "
         "throughout the enterprise.") ] 
    string SupportAccessId;
};
     
// ==================================================================
//    ProductSupport
// ==================================================================
        [Association, Description (
         "CIM_ProductSupport is an association between Product and "
         "SupportAccess that conveys how support is obtained for the "
         "Product.  This is a many-to-many relationship, implying that "
         "various types of Support are available for a Product, and "
         "that the same Support object can provide assistance for "
         "multiple Products.") ] 
class CIM_ProductSupport
{
        [Key, Description ("The Product.") ]     
    CIM_Product REF Product;
        [Key, Description ("Support for the Product.") ]
    CIM_SupportAccess REF Support;
};
     
// ==================================================================
//    FRU
// ==================================================================
        [Description (
         "The CIM_FRU class is a vendor-defined collection of Products "
         "and/or PhysicalElements that is associated with a "
         "Product for the purpose of supporting, maintaining or "
         "upgrading that Product at the customer's location. FRU is "
         "an acronym for 'field replaceable unit'. ") ] 
class CIM_FRU : CIM_ManagedElement
{
       [Override ("Description"), Description ("A textual description of the FRU."), 
	   MappingStrings {"MIF.DMTF|FRU|002.3"} ] 
    string Description;
        [Key, MaxLen (64), Description ("FRU ordering information."), 
	   MappingStrings {"MIF.DMTF|FRU|002.6"} ] 
    string FRUNumber;
        [Key, MaxLen (64), Description (
         "FRU identification such as a serial number on software or "
         "a die number on a hardware chip."), 
	   MappingStrings {"MIF.DMTF|FRU|002.7"} ] 
    string IdentifyingNumber;
        [Description ("FRU name."), MaxLen (256) ] 
    string Name;
        [Key, MaxLen (256),
	   Description ("The name of the FRU's supplier."), 
         MappingStrings {"MIF.DMTF|FRU|002.4"} ] 
    string Vendor;
        [MaxLen (64), Description ("The FRU's revision level."),
	   MappingStrings {"MIF.DMTF|FRU|002.8"} ] 
    string RevisionLevel;
};
     
// ==================================================================
//    ProductFRU
// ==================================================================
        [Association, Description (
         "CIM_ProductFRU is an association between Product and FRU "
         "that provides information regarding what Product components "
         "have been or are being replaced.  The association is one to "
         "many, conveying that a Product can have many FRUs, and that "
         "a particular instance of a FRU is only applied to one " 
         "(instance of a) Product.") ] 
class CIM_ProductFRU
{
        [Max (1), Key, Description (
	   "The Product to which the FRU is applied.") ] 
    CIM_Product REF Product;
	  [Key, Description ("The FRU.") ]
    CIM_FRU REF FRU;
};
     
// ==================================================================
//    ProductPhysicalElements
// ==================================================================
	  [Association, Aggregation, Description (
	   "Indicates the PhysicalElements that make up a Product.") ]
class CIM_ProductPhysicalElements
{
	  [Max (1), Aggregate, Key, Description ("The Product.") ]
    CIM_Product REF Product;
        [Key, Description (
	   "The PhysicalElement which is a part of the Product.") ]
    CIM_PhysicalElement REF Component;
};

// ==================================================================
//    FRUPhysicalElements
// ==================================================================
	  [Association, Aggregation, Description (
	   "Indicates the PhysicalElements that make up a FRU.") ]
class CIM_FRUPhysicalElements
{
	  [Max (1), Aggregate, Key, Description ("The FRU.") ]
    CIM_FRU REF FRU;
        [Key, Description (
	   "The PhysicalElement which is a part of the FRU.") ]
    CIM_PhysicalElement REF Component;
};

// ==================================================================
//    FRUIncludesProduct
// ==================================================================
 	  [Association, Aggregation, Description (
	   "Indicates that a FRU may be composed of other Product(s).") ]
class CIM_FRUIncludesProduct
{
	  [Max (1), Aggregate, Key, Description ("The FRU.") ]
    CIM_FRU REF FRU;
        [Key, Description (
	   "The Product which is a part of the FRU.") ]
    CIM_Product REF Component;
};

// ==================================================================
//    StatisticalInformation
// ================================================================== 
	  [Abstract, Description ( 
	   "CIM_StatisticalInformation is a root class for any arbitrary " 
	   "collection of statistical data and/or metrics applicable to " 
	   "one or more ManagedSystemElements.") ] 
class CIM_StatisticalInformation : CIM_ManagedElement
{ 
	  [MaxLen (256), Description ( 
	   "The Name property defines the label by which the statistic " 
	   "or metric is known. When subclassed, the property can be " 
	   "overridden to be a Key property. ") ] 
    string Name; 
};

// ==================================================================
//    Statistics
// ================================================================== 
	  [Association, Description ( 
	   "CIM_Statistics is an association that relates ManagedSystem" 
	   "Elements to the StatisticalGroup(s) that apply to them.") ]
class CIM_Statistics
{ 
	  [Key, Description ("The statistic information/object.") ] 
    CIM_StatisticalInformation REF Stats; 
	  [Key, Description ( 
	   "The ManagedSystemElement for which statistical or metric " 
	   "data is defined.") ] 
    CIM_ManagedSystemElement REF Element;
};

// ==================================================================
//    RelatedStatistics
// ================================================================== 
	  [Association, Description( 
	   "CIM_RelatedStatistics is an association that defines " 
	   "hierarchies and/or dependencies of related CIM_Statistical" 
	   "Information classes.") ]
class CIM_RelatedStatistics
{ 
	  [Key, Description ("The statistic information/object.") ] 
    CIM_StatisticalInformation REF Stats; 
	  [Key, Description ("The related statistics or metrics.") ] 
    CIM_StatisticalInformation REF RelatedStats;
};

// ==================================================================
//    SystemStatisticalInformation
// ==================================================================
        [Description (
         "Statistical information associated with a System object "
         "or one of its subclasses.") ]
class CIM_SystemStatisticalInformation : CIM_StatisticalInformation
{
        [Propagated("CIM_System.CreationClassName"), Key, 
         MaxLen (256), Description (
         "The scoping System's CreationClassName.") ]
   string SystemCreationClassName;
        [Propagated("CIM_System.Name"), Key, MaxLen (256), 
         Description ("The scoping System's Name.") ]
   string SystemName;
        [Key, MaxLen (256), Description (
         "CreationClassName indicates the name of the class or the "
         "subclass used in the creation of an instance. When used "
         "with the other key properties of this class, this property "
         "allows all instances of this class and its subclasses to "
         "be uniquely identified.") ]
   string CreationClassName;
        [Key, MaxLen (256), Override ("Name"), Description (
	   "The Name property, inherited from StatisticalInformation, "
         "serves as part of the object key.") ]
   string Name;
};

// ==================================================================
//    SystemStatistics
// ==================================================================
        [Association, Description (
         "SystemStatistics relates the SystemStatisticalInformation "
         "class to the System to which it applies.") ]
class CIM_SystemStatistics : CIM_Statistics
{
        [Override ("Stats"), Weak, Description (
         "The statistical object.") ]
   CIM_SystemStatisticalInformation REF Stats;
        [Override ("Element"), Min(1), Max(1), 
         Description ( "The System to which the statistics apply.") ]
   CIM_System REF Element;
};

// ==================================================================
//    ServiceStatisticalInformation
// ==================================================================
        [Description (
         "Statistical information associated with a Service object "
         "or one of its subclasses.") ]
class CIM_ServiceStatisticalInformation : CIM_StatisticalInformation
{
        [Propagated("CIM_Service.SystemCreationClassName"), Key, 
         MaxLen (256), Description (
         "The scoping System's CreationClassName.") ]
   string SystemCreationClassName;
        [Propagated("CIM_Service.SystemName"), Key, MaxLen (256), 
         Description ("The scoping System's Name.") ]
   string SystemName;
        [Propagated("CIM_Service.CreationClassName"), Key, 
         MaxLen (256), Description (
         "The scoping Service's CreationClassName.") ]
   string ServiceCreationClassName;
        [Propagated("CIM_Service.Name"), Key, MaxLen (256), 
         Description ("The scoping Service's Name.") ]
   string ServiceName;
        [Key, MaxLen (256), Description (
         "CreationClassName indicates the name of the class or the "
         "subclass used in the creation of an instance. When used "
         "with the other key properties of this class, this property "
         "allows all instances of this class and its subclasses to "
         "be uniquely identified.") ]
   string CreationClassName;
        [Key, MaxLen (256), Override ("Name"), Description (
	   "The Name property, inherited from StatisticalInformation, "
         "serves as part of the object key.") ]
   string Name;
};

// ==================================================================
//    ServiceStatistics
// ==================================================================
        [Association, Description (
         "ServiceStatistics relates the ServiceStatisticalInformation "
         "class to the Service to which it applies.") ]
class CIM_ServiceStatistics : CIM_Statistics
{
        [Override ("Stats"), Weak, 
         Description ( "The statistical object.") ]
   CIM_ServiceStatisticalInformation REF Stats;
        [Override ("Element"), Min(1), Max(1), 
         Description ( "The Service to which the statistics apply.") ]
   CIM_Service REF Element;
};

// ==================================================================
//    SAPStatisticalInformation
// ==================================================================
        [Description (
         "Statistical information associated with a Service"
         "AccessPoint object or one of its subclasses.") ]
class CIM_SAPStatisticalInformation : CIM_StatisticalInformation
{
        [Propagated("CIM_ServiceAccessPoint.SystemCreationClassName"),  
         Key, MaxLen (256), Description (
         "The scoping System's CreationClassName.") ]
   string SystemCreationClassName;
        [Propagated("CIM_ServiceAccessPoint.SystemName"), Key, 
	   MaxLen (256), Description ("The scoping System's Name.") ]
   string SystemName;
        [Propagated("CIM_ServiceAccessPoint.CreationClassName"), 
         Key, MaxLen (256), Description (
         "The scoping SAP's CreationClassName.") ]
   string SAPCreationClassName;
        [Propagated("CIM_ServiceAccessPoint.Name"), Key, 
         MaxLen (256), Description ("The scoping SAP's Name.") ]
   string SAPName;
        [Key, MaxLen (256), Description (
         "CreationClassName indicates the name of the class or the "
         "subclass used in the creation of an instance. When used "
         "with the other key properties of this class, this property "
         "allows all instances of this class and its subclasses to "
         "be uniquely identified.") ]
   string CreationClassName;
        [Key, MaxLen (256), Override ("Name"), Description (
	   "The Name property, inherited from StatisticalInformation, "
         "serves as part of the object key.") ]
   string Name;
};

// ==================================================================
//    SAPStatistics
// ==================================================================
        [Association, Description (
         "SAPStatistics relates the SAPStatisticalInformation "
         "class to the ServiceAccessPoint to which it applies. ") ]
class CIM_SAPStatistics : CIM_Statistics
{
        [Override ("Stats"), Weak, 
         Description ( "The statistical object.") ]
   CIM_SAPStatisticalInformation REF Stats;
        [Override ("Element"), Min(1), Max(1), Description (
         "The ServiceAccessPoint to which the statistics apply.") ]
   CIM_ServiceAccessPoint REF Element;
};

// ==================================================================
//    DeviceStatisticalInformation
// ==================================================================
        [Description (
         "Statistical information associated with a LogicalDevice "
         "or one of its subclasses.") ]
class CIM_DeviceStatisticalInformation : CIM_StatisticalInformation
{
        [Propagated("CIM_LogicalDevice.SystemCreationClassName"), Key, 
         MaxLen (256), Description (
         "The scoping System's CreationClassName.") ]
   string SystemCreationClassName;
        [Propagated("CIM_LogicalDevice.SystemName"), Key, MaxLen (256), 
         Description ("The scoping System's Name.") ]
   string SystemName;
        [Propagated("CIM_LogicalDevice.CreationClassName"), Key, 
         MaxLen (256), 
         Description ("The scoping Device's CreationClassName.") ]
   string DeviceCreationClassName;
        [Propagated("CIM_LogicalDevice.DeviceID"), Key, MaxLen (64), 
         Description ("The scoping Device's ID.") ]
   string DeviceID;
        [Key, MaxLen (256), Description (
         "CreationClassName indicates the name of the class or the "
         "subclass used in the creation of an instance. When used "
         "with the other key properties of this class, this property "
         "allows all instances of this class and its subclasses to "
         "be uniquely identified.") ]
   string CreationClassName;
        [Key, MaxLen (256), Override ("Name"), Description (
	   "The Name property, inherited from StatisticalInformation, "
         "serves as part of the object key.") ]
   string Name;
};

// ==================================================================
//    DeviceStatistics
// ==================================================================
        [Association, Description (
         "DeviceStatistics relates the DeviceStatisticalInformation "
         "class to the LogicalDevice to which it applies. ") ]
class CIM_DeviceStatistics : CIM_Statistics
{
        [Override ("Stats"), Weak, 
         Description ( "The statistical object.") ]
   CIM_DeviceStatisticalInformation REF Stats;
        [Override ("Element"), Min(1), Max(1), 
         Description ("The Device to which the statistics apply.") ]
   CIM_LogicalDevice REF Element;
};

// ==================================================================
//    PhysicalStatisticalInformation
// ==================================================================
        [Description (
         "Statistical information associated with a PhysicalElement "
         "or one of its subclasses.") ]
class CIM_PhysicalStatisticalInformation : CIM_StatisticalInformation
{
        [Propagated("CIM_PhysicalElement.CreationClassName"), Key, 
         MaxLen (256), 
         Description ("The scoping Element's CreationClassName.") ]
   string PhysicalCreationClassName;
        [Propagated("CIM_PhysicalElement.Tag"), Key, MaxLen (256), 
         Description ("The scoping Element's identifying Tag.") ]
   string Tag;
        [Key, MaxLen (256), Description (
         "CreationClassName indicates the name of the class or the "
         "subclass used in the creation of an instance. When used "
         "with the other key properties of this class, this property "
         "allows all instances of this class and its subclasses to "
         "be uniquely identified.") ]
   string CreationClassName;
        [Key, MaxLen (256), Override ("Name"), Description (
	   "The Name property, inherited from StatisticalInformation, "
         "serves as part of the object key.") ]
   string Name;
};

// ==================================================================
//    PhysicalStatistics
// ==================================================================
        [Association, Description (
         "PhysicalStatistics relates the PhysicalStatisticalInformation "
         "class to the PhysicalElement to which it applies. ") ]
class CIM_PhysicalStatistics : CIM_Statistics
{
        [Override ("Stats"), Weak, 
         Description ( "The statistical object.") ]
   CIM_PhysicalStatisticalInformation REF Stats;
        [Override ("Element"), Min(1), Max(1), Description (
         "The PhysicalElement to which the statistics apply.") ]
   CIM_PhysicalElement REF Element;
};


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

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

